@agent-os-sdk/client 0.9.14 → 0.9.16

package/src/modules/presets.ts

@@ -32,56 +32,111 @@ const TRIGGER_TYPE_MAP: Record<string, { type: string; template_slug: string }>
   schedule: { type: "schedule", template_slug: "cron" },
 };
 
-const OUTPUT_NODE_MAP: Record<string, { kind: string; config: Record<string, unknown> }> = {
-  chatwoot: { kind: "output.chatwoot", config: {} },
-  http: { kind: "output.http", config: {} },
-};
+function buildAgentDefinitionId(name: string): string {
+  const normalized = name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, ".")
+    .replace(/\.{2,}/g, ".")
+    .replace(/^\.|\.$/g, "");
+  return `agent.${normalized || "untitled"}`;
+}
 
-function generateGraphSpec(config: AgentTemplateConfig): Record<string, unknown> {
-  const triggerMapping = TRIGGER_TYPE_MAP[config.trigger_type] ?? TRIGGER_TYPE_MAP.webhook;
-  const outputMapping = OUTPUT_NODE_MAP[config.output_type] ?? OUTPUT_NODE_MAP.http;
-
-  // Safe validation (TS knows these keys exist in the constant, but runtime check is good practice)
-  if (!triggerMapping) throw new Error(`Invalid trigger type: ${config.trigger_type}`);
-  if (!outputMapping) throw new Error(`Invalid output type: ${config.output_type}`);
-
-  const nodes = [
-    {
-      id: "node-llm",
-      kind: "llm.chat",
-      label: "LLM",
-      config: {
-        model: config.llm?.model || "gpt-4o",
-        system_prompt: config.llm?.system_prompt || "You are a helpful assistant.",
-        ...(config.llm?.credential_id ? { credential_id: config.llm.credential_id } : {}),
+function generateAgentIr(config: AgentTemplateConfig): Record<string, unknown> {
+  const agentDefinitionId = buildAgentDefinitionId(config.name);
+  const triggerLabel = config.trigger_type === "schedule" ? "Scheduled Trigger" : "Incoming Trigger";
+  const outputLabel = config.output_type === "chatwoot" ? "Chatwoot Output" : "HTTP Output";
+
+  return {
+    ir_version: "1.0",
+    agent_definition_id: agentDefinitionId,
+    version: "1.0.0",
+    metadata: {
+      name: config.name,
+      description: "Preset-generated agent_ir.v1 draft",
+    },
+    state_schema: {
+      type: "object",
+      properties: {
+        global: {
+          type: "object",
+        },
       },
-      ui: { x: 300, y: 200 },
     },
-    {
-      id: "node-output",
-      ...outputMapping,
-      label: "Output",
-      ui: { x: 500, y: 200 },
+    inputs_schema: {
+      type: "object",
+      properties: {
+        message: {
+          type: "string",
+        },
+      },
+      required: ["message"],
     },
-  ];
-
-  const edges = [
-    { from: "node-llm", to: "node-output" },
-  ];
-
-  const triggers = [
-    {
-      type: `${triggerMapping.template_slug}.${triggerMapping.type}`,
-      config: { events: ["message_created"] },
+    outputs_schema: {
+      type: "object",
     },
-  ];
-
-  return {
-    version: "1",
-    entrypoint: "node-llm",
-    nodes,
-    edges,
-    triggers,
+    outcome_schema: {
+      type: "object",
+      properties: {
+        preset_ready: {
+          type: "boolean",
+        },
+      },
+      required: ["preset_ready"],
+    },
+    kpi_bindings: [
+      {
+        kpi_ref: `${agentDefinitionId}.preset_ready`,
+        source_scope: "outcome",
+        source_path: "preset_ready",
+      },
+    ],
+    evaluation_policy: {
+      execution_mode: "async",
+      evaluators: [
+        {
+          evaluator_ref: `eval.${agentDefinitionId}.preset_shape_v1`,
+          kind: "rule",
+        },
+      ],
+      sampling_policy: {
+        mode: "all",
+      },
+    },
+    improvement_policy_ref: null,
+    nodes: [
+      {
+        id: "start",
+        kind: "start",
+        label: triggerLabel,
+        config: {},
+        bindings: {},
+        editability: { mode: "read_only" },
+      },
+      {
+        id: "draft_output",
+        kind: "end",
+        label: outputLabel,
+        config: {},
+        bindings: {},
+        editability: { mode: "full" },
+      },
+    ],
+    edges: [
+      {
+        id: "edge_start_to_output",
+        from: "start",
+        to: "draft_output",
+        kind: "default",
+        priority: 0,
+      },
+    ],
+    capability_registry_refs: [],
+    policies: {},
+    editability: {
+      mode: "full",
+    },
+    entrypoints: ["start"],
   };
 }
 
@@ -129,14 +184,27 @@ export class PresetsModule {
         return null;
       }
 
-      const graphSpec = generateGraphSpec(config);
-
-      const { data: bundle, error: publishError } = await this._agents.publish(
+      const { error: draftError } = await this._agents.updateDraftIr(
         agent.id,
-        graphSpec,
-        { set_as_live: true, idempotency_key: generateUUID() }
+        generateAgentIr(config),
+        { if_match: `"${agent.id}:0"` },
       );
 
+      if (draftError) {
+        console.error("[AgentOS SDK] Failed to save agent_ir.v1 draft:", draftError);
+        return {
+          agent_id: agent.id,
+          agent_name: agent.name,
+          status: "draft",
+        };
+      }
+
+      const { data: bundle, error: publishError } = await this._agents.publish(agent.id, {
+        set_as_live: true,
+        required_tools: [],
+        idempotency_key: generateUUID(),
+      });
+
       if (publishError) {
         console.error("[AgentOS SDK] Failed to publish bundle:", publishError);
         return {

package/src/modules/runs.ts

@@ -82,6 +82,9 @@ export interface RunEventDto {
     timestamp: string;
     attempt_id: string;
     payload: Record<string, unknown> | null;
+    operation_id: string;
+    parent_operation_id?: string | null;
+    root_operation_id: string;
 }
 
 export class RunsModule {
@@ -645,12 +648,15 @@ export interface FollowEvent {
     seq: number;
     timestamp: string;
     payload?: Record<string, unknown> | null;
+    operation_id?: string;
+    parent_operation_id?: string | null;
+    root_operation_id?: string;
     /** For run_event: the node that emitted this event */
     node?: string;
 }
 
 /** Narrow raw SSE event to FollowEvent */
-function narrowFollowEvent(raw: SSEEvent<unknown>): FollowEvent | null {
+export function narrowFollowEvent(raw: SSEEvent<unknown>): FollowEvent | null {
     const eventType = raw.event ?? "message";
     const validTypes = ["run_event", "heartbeat", "close", "error"];
 
@@ -668,6 +674,13 @@ function narrowFollowEvent(raw: SSEEvent<unknown>): FollowEvent | null {
         const innerPayload = (typeof data.payload === "object" && data.payload !== null)
             ? (data.payload as Record<string, unknown>)
             : null;
+        const operationId = typeof data.operation_id === "string" ? data.operation_id : undefined;
+        const parentOperationId = typeof data.parent_operation_id === "string"
+            ? data.parent_operation_id
+            : data.parent_operation_id === null
+                ? null
+                : undefined;
+        const rootOperationId = typeof data.root_operation_id === "string" ? data.root_operation_id : undefined;
 
         return {
             type: "run_event",
@@ -677,7 +690,13 @@ function narrowFollowEvent(raw: SSEEvent<unknown>): FollowEvent | null {
                 ...(innerPayload ?? {}),
                 type: typeof data.type === "string" ? data.type : "UNKNOWN",
                 attempt_id: typeof data.attempt_id === "string" ? data.attempt_id : undefined,
+                operation_id: operationId,
+                parent_operation_id: parentOperationId,
+                root_operation_id: rootOperationId,
             },
+            operation_id: operationId,
+            parent_operation_id: parentOperationId,
+            root_operation_id: rootOperationId,
             node: typeof innerPayload?.node === "string" ? innerPayload.node : undefined,
         };
     }

package/src/modules/templates.ts

@@ -0,0 +1,40 @@
+import type { APIResponse, RawClient } from "../client/raw.js";
+
+export interface AuthoringTemplateSummary {
+    template_ref: string;
+    version: string;
+    display_name: string;
+    description?: string | null;
+    template_kind: string;
+    category: string;
+    editability_mode: string;
+    required_capability_refs: string[];
+    default_policy_refs?: Record<string, unknown> | null;
+    default_runtime_config_refs?: Record<string, unknown> | null;
+}
+
+export interface AuthoringTemplateDetail extends AuthoringTemplateSummary {
+    base_agent_ir: Record<string, unknown>;
+}
+
+export interface AuthoringTemplateListResponse {
+    items: AuthoringTemplateSummary[];
+    total: number;
+}
+
+export class TemplatesModule {
+    constructor(private client: RawClient, private headers: () => Record<string, string>) {}
+
+    async list(): Promise<APIResponse<AuthoringTemplateListResponse>> {
+        return this.client.GET<AuthoringTemplateListResponse>("/v1/api/templates", {
+            headers: this.headers(),
+        });
+    }
+
+    async get(templateRef: string): Promise<APIResponse<AuthoringTemplateDetail>> {
+        return this.client.GET<AuthoringTemplateDetail>("/v1/api/templates/{templateRef}", {
+            params: { path: { templateRef } },
+            headers: this.headers(),
+        });
+    }
+}

package/src/modules/tools.ts

@@ -19,6 +19,22 @@ export interface ToolListResponse {
     total: number;
 }
 
+export interface ToolDefinitionCatalogItem {
+    slug: string;
+    name: string;
+    description?: string;
+    type: string;
+    version?: number;
+    input_schema?: Record<string, unknown>;
+    output_schema?: Record<string, unknown>;
+    credential_requirements?: unknown[];
+}
+
+export interface ToolDefinitionCatalogResponse {
+    version: string;
+    tools: ToolDefinitionCatalogItem[];
+}
+
 export interface ToolCallResult {
     success: boolean;
     output?: unknown;
@@ -52,6 +68,13 @@ export class ToolsModule {
         });
     }
 
+    async getDefinitions(version: string = "1"): Promise<APIResponse<ToolDefinitionCatalogResponse>> {
+        return this.client.GET<ToolDefinitionCatalogResponse>("/v1/api/tools/definitions", {
+            params: { query: { version } },
+            headers: this.headers(),
+        });
+    }
+
     /**
      * Call a tool directly (testing).
      */