@agent-compose/sdk 0.2.4 → 0.3.0

package/dist/runtimes/openai-desktop.js

@@ -481,14 +481,18 @@ function extractMetadata(source) {
     out.networkPolicy = freezeMetadataValue(source.networkPolicy);
   if (source.placeholders !== undefined)
     out.placeholders = Object.freeze({ ...source.placeholders });
-  if (source.snapshot !== undefined)
-    out.snapshot = source.snapshot;
-  if (source.saveSnapshot !== undefined)
-    out.saveSnapshot = source.saveSnapshot;
+  if (source.inputSchema !== undefined)
+    out.inputSchema = freezeMetadataValue(source.inputSchema);
+  if (source.outputSchema !== undefined)
+    out.outputSchema = freezeMetadataValue(source.outputSchema);
+  if (source.snapshots !== undefined)
+    out.snapshots = Object.freeze({ ...source.snapshots });
   if (source.processors !== undefined)
     out.processors = Object.freeze([...source.processors]);
   if (source.memory !== undefined)
-    out.memory = typeof source.memory === "object" && source.memory !== null ? Object.freeze({ ...source.memory }) : source.memory;
+    out.memory = source.memory;
+  if (source.postRunHooks !== undefined)
+    out.postRunHooks = Object.freeze([...source.postRunHooks]);
   return Object.freeze(out);
 }
 function freezeMetadataValue(value) {
@@ -583,7 +587,8 @@ function defineSandboxEnvironment(env) {
     throw new Error(`defineSandboxEnvironment(${env.name}): 'setup' must be a function`);
   }
   return defineWorkflow({
-    saveSnapshot: env.saveSnapshot ?? true,
+    snapshots: env.snapshots ?? { saveLatest: true },
+    memory: env.memory ?? false,
     run: async (_ctx, sandbox) => env.setup(sandbox)
   });
 }
@@ -695,12 +700,18 @@ function templatePath(factorySlug, ...rest) {
   const tail = rest.length > 0 ? "/" + rest.map(encodeURIComponent).join("/") : "";
   return `/api/v1/factories/${encodeURIComponent(factorySlug)}/templates${tail}`;
 }
+var PUBLIC_API_HOST = "https://api.agentcompose.ai";
 
 class AgentComposeClient {
   fetch;
   baseUrl;
   apiKey;
-  constructor(baseUrl, apiKey) {
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_API_KEY : undefined) ?? "";
+    if (!apiKey) {
+      throw new Error("AgentComposeClient: `apiKey` is required. Pass it as `{ apiKey }` " + "or set the AGENT_COMPOSE_API_KEY env var.");
+    }
+    const baseUrl = options.baseUrl ?? (typeof process !== "undefined" ? process.env?.AGENT_COMPOSE_URL : undefined) ?? PUBLIC_API_HOST;
     this.baseUrl = baseUrl.replace(/\/$/, "");
     this.apiKey = apiKey;
     this.fetch = ofetch.create({
@@ -723,10 +734,11 @@ class AgentComposeClient {
       method: "POST",
       body: {
         input,
-        ...opts?.snapshot !== undefined ? { snapshot: opts.snapshot } : {},
-        ...opts?.saveSnapshot !== undefined ? { saveSnapshot: opts.saveSnapshot } : {},
+        ...opts?.snapshots !== undefined ? { snapshots: opts.snapshots } : {},
         ...opts?.networkPolicy !== undefined ? { networkPolicy: opts.networkPolicy } : {},
         ...opts?.placeholders !== undefined ? { placeholders: opts.placeholders } : {},
+        ...opts?.memory !== undefined ? { memory: opts.memory } : {},
+        ...opts?.postRunHooks !== undefined ? { postRunHooks: opts.postRunHooks } : {},
         ...parentRunId ? { parentRunId } : {},
         ...opts?.agentId ? { agentId: opts.agentId } : {}
       }
@@ -747,16 +759,29 @@ class AgentComposeClient {
     throw new AgentComposeError(504, `invokeAndWait: run ${runId} did not settle within ${timeoutMs}ms`);
   }
   async listSnapshots(opts) {
+    const body = await this.listSnapshotsPage(opts);
+    return body.data;
+  }
+  async listSnapshotsPage(opts) {
+    const factorySlug = opts?.factorySlug ?? DEFAULT_FACTORY;
     const q2 = new URLSearchParams;
     if (opts?.workflow)
       q2.set("workflow", opts.workflow);
     if (opts?.limit != null)
       q2.set("limit", String(opts.limit));
-    const body = await this.fetch(`/api/v1/snapshots${q2.toString() ? `?${q2}` : ""}`);
-    return body.data;
+    if (opts?.before)
+      q2.set("before", opts.before);
+    return this.fetch(`/api/v1/factories/${encodeURIComponent(factorySlug)}/snapshots${q2.toString() ? `?${q2}` : ""}`);
   }
   deleteSnapshot(runId) {
-    return this.fetch(`/api/v1/workflows/${runId}/snapshot`, { method: "DELETE" });
+    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshot`, { method: "DELETE" });
+  }
+  async listRunSnapshots(runId) {
+    const body = await this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshots`);
+    return body.data;
+  }
+  deleteRunSnapshot(runId, snapshotId) {
+    return this.fetch(`/api/v1/workflows/${encodeURIComponent(runId)}/snapshots/${encodeURIComponent(snapshotId)}`, { method: "DELETE" });
   }
   getStatus(runId) {
     return this.fetch(`/api/v1/workflows/${runId}/status`);
@@ -946,7 +971,7 @@ async function extractFromBundle(source, label, pick) {
     return;
   }
 }
-var DEFINE_WORKFLOW_CALLEE = /^defineWorkflow\d*$/;
+var DEFINE_WORKFLOW_CALLEE = /^(?:defineWorkflow|defineSandboxEnvironment)\d*$/;
 function isDefineWorkflowCall(node) {
   if (node.callee.type === "Identifier") {
     return DEFINE_WORKFLOW_CALLEE.test(node.callee.name);
@@ -1017,17 +1042,59 @@ async function bundleWorkflow(workflowPath, overrides) {
     sourceHash: sha256(source),
     bundlerVersion: BUNDLER_VERSION
   };
+  const inputSchema = extractIOSchema(workflow.input);
+  const outputSchema = extractIOSchema(workflow.output);
   return {
     source,
     manifest,
     workflowPlan: plan,
     networkPolicy: overrides?.networkPolicy ?? metadata.networkPolicy,
     placeholders: overrides?.placeholders ?? metadata.placeholders,
-    ...metadata.snapshot !== undefined ? { snapshot: metadata.snapshot } : {},
-    ...metadata.saveSnapshot !== undefined ? { saveSnapshot: metadata.saveSnapshot } : {},
-    ...metadata.memory !== undefined ? { memory: metadata.memory } : {}
+    ...inputSchema !== undefined ? { inputSchema } : {},
+    ...outputSchema !== undefined ? { outputSchema } : {},
+    ...metadata.snapshots !== undefined ? { snapshots: metadata.snapshots } : {},
+    ...metadata.memory !== undefined ? { memory: metadata.memory } : {},
+    ...metadata.postRunHooks !== undefined ? { postRunHooks: metadata.postRunHooks } : {}
   };
 }
+function extractIOSchema(zodSchema) {
+  let json;
+  try {
+    const z3 = __require("zod");
+    if (!z3.toJSONSchema)
+      return;
+    json = z3.toJSONSchema(zodSchema);
+  } catch {
+    return;
+  }
+  if (!json || typeof json !== "object")
+    return;
+  if (Object.keys(json).filter((k) => k !== "$schema").length === 0)
+    return;
+  const out = {};
+  if (json.type !== undefined)
+    out.type = json.type;
+  if (json.description !== undefined)
+    out.description = String(json.description);
+  if (json.properties && typeof json.properties === "object") {
+    const props = {};
+    for (const [key, raw] of Object.entries(json.properties)) {
+      if (raw && typeof raw === "object") {
+        const r = raw;
+        props[key] = {};
+        if (r.type !== undefined)
+          props[key].type = r.type;
+        if (r.description !== undefined)
+          props[key].description = String(r.description);
+      }
+    }
+    if (Object.keys(props).length > 0)
+      out.properties = props;
+  }
+  if (Array.isArray(json.required))
+    out.required = json.required.map(String);
+  return out;
+}
 // src/utils/schemas.ts
 import { z as z3 } from "zod";
 var AgentStatusSchema = z3.object({
@@ -1544,7 +1611,11 @@ function makeVercelSandboxProvider(sb, globalEnvs) {
     },
     async snapshot() {
       const res = await sb.snapshot({ expiration: 0 });
-      return { snapshotId: res.snapshotId };
+      const sizeBytes = typeof res.sizeBytes === "number" ? res.sizeBytes : undefined;
+      return {
+        snapshotId: res.snapshotId,
+        ...sizeBytes !== undefined ? { sizeBytes } : {}
+      };
     }
   };
 }
@@ -2049,7 +2120,7 @@ function buildInvokeChild(runId, opts = {}) {
     if (!baseUrl || !apiKey) {
       throw new Error("ctx.invokeChild requires AGENT_COMPOSE_URL and AGENT_COMPOSE_API_KEY");
     }
-    childClient = new AgentComposeClient(baseUrl, apiKey);
+    childClient = new AgentComposeClient({ apiKey, baseUrl });
     return childClient;
   };
   return (name, input, childOpts) => getChildClient().invokeAndWait(name, input, {

package/dist/types/sandbox-environment.d.ts

@@ -1,16 +1,14 @@
 /**
  * A sandbox environment is a workflow whose job is to leave its VM in a
  * configured state, then snapshot it so other workflows can boot from that
- * state. Capture is **opt-in**: the wrapper below sets `saveSnapshot: true`
- * by default (opt out with `saveSnapshot: false` if you only want side
- * effects).
+ * state. Capture is **opt-in**: the wrapper below sets
+ * `snapshots: { saveLatest: true }` by default (opt out with
+ * `saveLatest: false` if you only want side effects).
  *
- * Once captured, reference the snapshot from another workflow's `snapshot`
- * field by run UUID, workflow name, or `name@version`:
+ * Once captured, reference the snapshot from another workflow's
+ * `snapshots.bootFrom` field by provider snapshot id:
  *
- *     snapshot: "my-setup"          // most recent successful snapshot
- *     snapshot: "my-setup@v1"       // version-scoped recency
- *     snapshot: "<run-uuid>"        // pinned to an exact run
+ *     snapshots: { bootFrom: { snapshotId: "snap_..." } }
  *
  * `defineSandboxEnvironment` is sugar over `defineWorkflow` — it makes the
  * setup recipe read like an imperative script by supplying the local
@@ -20,7 +18,7 @@
  *   1. Author a setup file with `defineSandboxEnvironment`.
  *   2. `agentc register setup.ts --build` — registers and invokes once to
  *      capture the snapshot.
- *   3. Other workflows declare `snapshot: "name"` and boot from it.
+ *   3. Other workflows declare `snapshots: { bootFrom: { snapshotId } }`.
  *   4. `agentc snapshot list` / `delete` to manage the Vercel storage bill.
  *
  * @example
@@ -37,16 +35,27 @@
  */
 import type { SandboxProvider } from "./sandbox.js";
 import type { Workflow } from "../workflow-steps/types.js";
+import type { SnapshotConfig } from "./workflow-metadata.js";
 export interface SandboxEnvironmentDefinition {
     name: string;
     description?: string;
     setup: (sb: SandboxProvider) => Promise<void>;
-    /** Override the sugar's `saveSnapshot: true` default. Set `false` to opt
-     *  out of snapshot capture (rarely useful — an env with no snapshot can't
-     *  be referenced as the `snapshot` field on another workflow). */
-    saveSnapshot?: boolean;
+    /** Override the sugar's `{ saveLatest: true }` default. Set
+     *  `{ saveLatest: false }` to opt out of snapshot capture (rarely
+     *  useful — an env with no snapshot can't be referenced as a
+     *  `bootFrom` on another workflow). */
+    snapshots?: SnapshotConfig;
+    /** Override the sugar's `memory: false` default. Setup workflows
+     *  don't typically benefit from memory extraction; opt in explicitly
+     *  when they do. */
+    memory?: boolean;
 }
 /** Sugar over `defineWorkflow` for setup-only workflows that exist to
  *  capture a snapshot. The workflow takes no meaningful input and returns
- *  nothing — its value is the side effect on the sandbox VM. */
+ *  nothing — its value is the side effect on the sandbox VM.
+ *
+ *  Defaults `memory: false` because sandbox environments emit setup
+ *  output (npm installs, command exit codes) rather than agent traces
+ *  worth memorising. Authors can opt in explicitly via `env.memory:
+ *  true` if their environment somehow does want extraction. */
 export declare function defineSandboxEnvironment(env: SandboxEnvironmentDefinition): Workflow<Record<string, unknown>, void>;

package/dist/types/sandbox.d.ts

@@ -29,9 +29,14 @@ export interface SandboxProvider {
     /** Capture the running sandbox's state as a reusable snapshot. Vercel
      *  supports it natively; E2B's model is Dockerfile-based and doesn't map
      *  cleanly — `undefined` on providers that don't. Used by the server's
-     *  `--build` flow to stamp the snapshot id on the workflow row. */
+     *  `--build` flow to stamp the snapshot id on the workflow row.
+     *
+     *  `sizeBytes` is the on-disk footprint reported by the provider. May
+     *  be omitted when the provider doesn't expose it; the server stores
+     *  `null` for missing values rather than estimating. */
     snapshot?(): Promise<{
         snapshotId: string;
+        sizeBytes?: number;
     }>;
 }
 /** Stateless provider-level snapshot deletion — no live sandbox needed,

package/dist/types/workflow-metadata.d.ts

@@ -18,19 +18,83 @@ import type { Processor } from "../processors/processor.js";
  * The bundler reads these from the default export at registration time
  * and forwards them to the server's POST /api/v1/templates payload.
  */
-/** Server-side knob for whether/how a Workflow Memory agent should run
- *  after this workflow completes. `"default"` runs the built-in extractor;
- *  `false` disables; an object names a custom memory workflow to dispatch. */
-export type WorkflowMemoryConfig = "default" | false | {
-    workflow: string;
+/** Whether the built-in Workflow Memory extractor should run after this
+ *  workflow completes. Boolean toggle — custom post-run workflows live
+ *  in the separate `postRunHooks` array on `WorkflowMetadata`. */
+export type WorkflowMemoryConfig = boolean;
+/** Where a run boots from. The snapshot id is the unit of identity —
+ *  each captured snapshot already records the workflow + version it
+ *  came from on the snapshot row, so there's no separate "latest of
+ *  workflow X" resolution at dispatch time. Operators pick a snapshot
+ *  from the dashboard snapshot list (or `agentc snapshot list`) and
+ *  paste the id here.
+ *
+ *  Omit `bootFrom` entirely to boot a fresh base sandbox. */
+export type BootSnapshot = {
+    snapshotId: string;
 };
+/** Snapshot configuration — boot source plus capture knobs. One object
+ *  per workflow / per invocation; collapsing boot + capture under a
+ *  single key reads as "all snapshot config lives here." */
+export interface SnapshotConfig {
+    /** Where the runner restores from at run start. Structured (workflow
+     *  ref or snapshot id) so the intent is explicit at the call site. */
+    bootFrom?: BootSnapshot;
+    /** Capture the sandbox state on terminal success. The latest pointer
+     *  on `workflow_runs.vercel_snapshot_id` always tracks the most
+     *  recent capture; without `retainSteps`, prior captures are deleted
+     *  as new ones land — constant storage cost. */
+    saveLatest?: boolean;
+    /** Only meaningful with `saveLatest: true`. Retain every step's
+     *  snapshot in `run_step_snapshots` so a future dispatch can boot
+     *  from a specific step's checkpoint via its `snapshotId`. Cost
+     *  scales linearly with step count. */
+    retainSteps?: boolean;
+}
+/** JSON-Schema-shaped description captured by the bundler from a
+ *  workflow's `input` or `output` zod schema. Carried in template
+ *  metadata so the dashboard can render typed input forms + output
+ *  type tables. */
+export interface IOSchema {
+    /** JSON Schema `type` keyword, when single-valued. Omitted for unions / unknowns. */
+    type?: string | string[];
+    /** Free-form description pulled from `.describe(...)` on the root. */
+    description?: string;
+    /** Object-shape: one entry per property. */
+    properties?: Record<string, {
+        type?: string | string[];
+        description?: string;
+    }>;
+    /** Required property names — relevant only when `type === "object"`. */
+    required?: string[];
+}
+/** Alias kept for backwards source-compatibility with the original
+ *  output-only release. New code should prefer `IOSchema`. */
+export type OutputSchema = IOSchema;
 export interface WorkflowMetadata {
     networkPolicy?: SandboxNetworkPolicy;
     placeholders?: Record<string, string>;
-    snapshot?: string;
-    saveSnapshot?: boolean;
+    /** Input schema captured at bundle time from the workflow's
+     *  declared `input` zod schema. Step-form workflows populate this
+     *  automatically; run-form workflows (no explicit input schema —
+     *  defaults to `z.unknown()`) leave it undefined. */
+    inputSchema?: IOSchema;
+    /** Output schema captured at bundle time from the workflow's
+     *  declared `output` zod schema. Step-form workflows populate this
+     *  automatically; run-form workflows whose `run()` returns
+     *  arbitrarily-typed values leave it undefined. */
+    outputSchema?: IOSchema;
+    /** All snapshot config — boot source + capture mode. */
+    snapshots?: SnapshotConfig;
     processors?: readonly Processor[];
-    memory?: WorkflowMemoryConfig;
+    /** Run the built-in memory extractor after this workflow completes.
+     *  Opt-in; defaults to false when omitted. */
+    memory?: boolean;
+    /** Ordered list of workflow names that run after this workflow
+     *  completes. The runtime dispatches them in declaration order; the
+     *  built-in memory extractor (when `memory: true`) runs as a separate
+     *  hook alongside whatever's declared here. */
+    postRunHooks?: readonly string[];
 }
 /**
  * Pull the server-readable declarations off a source object (run-form

package/dist/types/workflow.d.ts

@@ -25,8 +25,8 @@ export type { WorkflowMetadata } from "./workflow-metadata.js";
 export interface AgentEventSink {
     emit(event: AgentLifecycleEvent): void | Promise<void>;
 }
-import type { WorkflowMemoryConfig } from "./workflow-metadata.js";
-export type { WorkflowMemoryConfig };
+import type { WorkflowMemoryConfig, SnapshotConfig, BootSnapshot, IOSchema, OutputSchema } from "./workflow-metadata.js";
+export type { WorkflowMemoryConfig, SnapshotConfig, BootSnapshot, IOSchema, OutputSchema };
 /** Turn/iteration budget for `agent(opts)`. Re-exported here so authors
  *  can type per-invoke budget overrides they pass as workflow input. */
 export interface AgentBudget {
@@ -69,21 +69,21 @@ export type WorkflowFn<TOutput = unknown, TInput extends Record<string, unknown>
 export interface WorkflowDefinition<TOutput = unknown, TInput extends Record<string, unknown> = Record<string, unknown>> {
     run: WorkflowFn<TOutput, TInput>;
     /**
-     * Reference to a snapshot the runner should boot from at run start.
-     * Accepts a run UUID, a workflow name, or `name@version` — any workflow
-     * registered with `--build` produces a snapshot you can name here. The
-     * runner VM starts in that pre-configured state. Per-invocation
-     * `invoke({ snapshot })` overrides this default.
-     */
-    snapshot?: string;
-    /**
-     * Capture a snapshot of the sandbox on successful /complete. Snapshots
-     * are long-lived (never auto-expire) — customers list + delete them
-     * explicitly via `agentc snapshot list/delete`. Per-invocation
-     * `invoke({ saveSnapshot })` overrides this default.
-     * `defineSandboxEnvironment` sugar sets this to true by default.
+     * All snapshot config — boot source plus capture mode.
+     *
+     * `snapshots.bootFrom`: the runner restores from this exact provider
+     * snapshot id at run start. Omit to boot a fresh sandbox.
+     *
+     * `snapshots.saveLatest`: `true` captures one snapshot after each
+     * successful step (latest-only — prior is freed).
+     * `{ saveLatest: true, retainSteps: true }` keeps every step's
+     * snapshot for fork / replay / time-travel.
+     *
+     * Snapshots are long-lived (never auto-expire). List + delete via
+     * `agentc snapshot list/delete`. Per-invocation
+     * `invoke({ snapshots })` overrides this default.
      */
-    saveSnapshot?: boolean;
+    snapshots?: SnapshotConfig;
     /**
      * Outbound network policy for the runner sandbox.
      * Use "*": [] to allow all traffic while still injecting headers for specific domains.
@@ -120,10 +120,14 @@ export interface WorkflowDefinition<TOutput = unknown, TInput extends Record<str
      * }
      */
     placeholders?: Record<string, string>;
-    /** Workflow Memory extraction. Defaults to "default" when omitted.
-     * Set false to skip memory extraction for this workflow, or point at a
-     * custom memory workflow once custom extractors are supported. */
+    /** Run the built-in memory extractor after this workflow completes.
+     *  Opt-in; defaults to false when omitted. */
     memory?: WorkflowMemoryConfig;
+    /** Ordered list of workflow names to dispatch as post-hooks after
+     *  this workflow completes. Each hook receives the source run's
+     *  context. The memory extractor (when `memory: true`) runs as an
+     *  additional hook alongside these. */
+    postRunHooks?: readonly string[];
 }
 /**
  * Declare a workflow. Two forms; both return a `Workflow` whose

package/dist/utils/bundler.d.ts

@@ -19,7 +19,7 @@
  * this function returns alongside the bundled bytes, and cross-checks the
  * manifest's `sourceHash` against the source it received.
  */
-import type { WorkflowMemoryConfig } from "../types/workflow.js";
+import type { WorkflowMemoryConfig, SnapshotConfig } from "../types/workflow.js";
 import type { SandboxNetworkPolicy } from "../sandbox.js";
 import { type WorkflowPlan } from "../types/workflow-plan.js";
 /** Bumped when the manifest contract changes in a way the server should
@@ -51,15 +51,20 @@ export interface BundledWorkflow {
     manifest: WorkflowManifest;
     networkPolicy?: SandboxNetworkPolicy;
     placeholders?: Record<string, string>;
-    /** Run UUID, workflow name, or `name@version` referencing the snapshot
-     *  this workflow's runner boots from, if declared via the `snapshot`
-     *  field on `defineWorkflow`. */
-    snapshot?: string;
-    /** Default capture-on-success flag from the workflow definition. */
-    saveSnapshot?: boolean;
+    /** Snapshot config from the workflow definition — `bootFrom` (where to
+     *  restore at run start), `save`, `retain`. */
+    snapshots?: SnapshotConfig;
     workflowPlan: WorkflowPlan;
     /** Workflow Memory extractor config. */
     memory?: WorkflowMemoryConfig;
+    /** Ordered post-hook workflow names declared on the workflow. */
+    postRunHooks?: readonly string[];
+    /** Compact JSON-Schema-shaped description of the workflow's input
+     *  type. Extracted from the workflow's declared `input` zod schema
+     *  at bundle time; undefined when the schema is `z.unknown()`. */
+    inputSchema?: import("../types/workflow-metadata.js").IOSchema;
+    /** Same for the workflow's output zod schema. */
+    outputSchema?: import("../types/workflow-metadata.js").IOSchema;
 }
 /**
  * Parse the bundled source and assert the default export is a CallExpression

package/dist/workflow-steps/workflow.d.ts

@@ -20,6 +20,7 @@
  */
 import type { z } from "zod";
 import type { Step, Workflow } from "./types.js";
+import type { SnapshotConfig, WorkflowMemoryConfig } from "../types/workflow-metadata.js";
 import type { SandboxNetworkPolicy } from "../sandbox.js";
 import type { Processor } from "../processors/processor.js";
 export interface WorkflowBuilder<TInput, TCurrent> {
@@ -41,8 +42,9 @@ export interface StepWorkflowDefinition<TInput, TOutput> {
     output: z.ZodType<TOutput>;
     networkPolicy?: SandboxNetworkPolicy;
     placeholders?: Record<string, string>;
-    snapshot?: string;
-    saveSnapshot?: boolean;
+    snapshots?: SnapshotConfig;
+    memory?: WorkflowMemoryConfig;
+    postRunHooks?: readonly string[];
     processors?: readonly Processor[];
 }
 export declare function createStepWorkflow<TInput, TOutput>(opts: StepWorkflowDefinition<TInput, TOutput>): WorkflowBuilder<TInput, TInput>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-compose/sdk",
-  "version": "0.2.4",
+  "version": "0.3.0",
   "description": "Client library for agent-compose — define agents, runtimes, and workflows, and invoke them against an agent-compose server.",
   "license": "MIT",
   "repository": {