Add release workflow and SDK coverage

Author: vamgan

.github/workflows/publish.yml

@@ -0,0 +1,31 @@
+name: Publish
+
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Package version to publish, for example 0.1.0"
+        required: true
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          registry-url: https://registry.npmjs.org
+          cache: npm
+      - run: npm ci
+      - run: npm run typecheck
+      - run: npm test
+      - run: npm run build
+      - run: npm version "${{ inputs.version }}" --no-git-tag-version
+      - run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

docs/release.md

@@ -0,0 +1,13 @@
+# Release Workflow
+
+`@agentdispatch/sdk` is published after `@agentdispatch/core`.
+
+## Prerequisites
+
+- Publish `@agentdispatch/core` for the target compatibility line.
+- Add an npm automation token as `NPM_TOKEN` in repository secrets.
+- Replace bootstrap `file:../agentdispatch-core` development links with the published core version before the first registry release.
+
+## Publish
+
+Use the `Publish` GitHub Actions workflow with the target version. The workflow validates typecheck, tests, and build before publishing with npm provenance.

test/client.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, it } from "vitest";
+import type { DispatchRequest, RuntimeService } from "@agentdispatch/core";
+import { AgentDispatchClient } from "../src/index.js";
+
+const request: DispatchRequest = {
+  provider: "aws",
+  accountProfile: "dev-aws",
+  capability: "agent-runtime",
+  taskType: "agent.run",
+  target: { mode: "session" },
+  input: { instruction: "run a long task" }
+};
+
+describe("AgentDispatchClient", () => {
+  it("delegates task lifecycle calls to the configured runtime service", async () => {
+    const calls: string[] = [];
+    const runtime = {
+      dispatchTask: async (dispatchRequest: DispatchRequest) => {
+        calls.push(`dispatch:${dispatchRequest.provider}`);
+        return {
+          taskId: "task_sdk",
+          status: "provisioning",
+          provider: dispatchRequest.provider,
+          accountProfile: dispatchRequest.accountProfile,
+          capability: dispatchRequest.capability,
+          backend: "aws-agentcore",
+          poll: {
+            statusTool: "get_task_status",
+            logsTool: "get_task_logs",
+            resultTool: "get_task_result"
+          }
+        };
+      },
+      getTaskStatus: async (taskId: string) => {
+        calls.push(`status:${taskId}`);
+        return { id: taskId, status: "running" };
+      },
+      getTaskLogs: async (taskId: string, cursor?: number, limit?: number) => {
+        calls.push(`logs:${taskId}:${cursor}:${limit}`);
+        return { taskId, cursor, nextCursor: 5, data: "hello" };
+      },
+      getTaskResult: async (taskId: string) => {
+        calls.push(`result:${taskId}`);
+        return { taskId, status: "succeeded", artifacts: [] };
+      },
+      cancelTask: async (taskId: string) => {
+        calls.push(`cancel:${taskId}`);
+        return { status: "cancelled" };
+      },
+      listProviders: () => {
+        calls.push("providers");
+        return ["aws"];
+      },
+      listCapabilities: (provider?: string) => {
+        calls.push(`capabilities:${provider}`);
+        return [{ adapter: "aws-agentcore", provider: "aws", capability: "agent-runtime", taskTypes: ["agent.run"], targetModes: ["session"] }];
+      },
+      listAccountProfiles: () => {
+        calls.push("accounts");
+        return [{ name: "dev-aws", provider: "aws", credentialSource: "aws-sdk-default" }];
+      }
+    } as unknown as RuntimeService;
+
+    const client = new AgentDispatchClient(runtime);
+
+    await expect(client.dispatchTask(request)).resolves.toMatchObject({ taskId: "task_sdk", backend: "aws-agentcore" });
+    await expect(client.getTaskStatus("task_sdk")).resolves.toMatchObject({ status: "running" });
+    await expect(client.getTaskLogs("task_sdk", 0, 128)).resolves.toMatchObject({ data: "hello" });
+    await expect(client.getTaskResult("task_sdk")).resolves.toMatchObject({ status: "succeeded" });
+    await expect(client.cancelTask("task_sdk")).resolves.toMatchObject({ status: "cancelled" });
+    expect(client.listProviders()).toEqual(["aws"]);
+    expect(client.listCapabilities("aws")).toHaveLength(1);
+    expect(client.listAccountProfiles()).toHaveLength(1);
+    expect(calls).toEqual([
+      "dispatch:aws",
+      "status:task_sdk",
+      "logs:task_sdk:0:128",
+      "result:task_sdk",
+      "cancel:task_sdk",
+      "providers",
+      "capabilities:aws",
+      "accounts"
+    ]);
+  });
+});