@agent-os-sdk/client 0.9.21 → 0.9.23

package/src/generated/swagger.json

@@ -1238,6 +1238,130 @@
         }
       }
     },
+    "/v1/api/agents/{id}/publish-preview": {
+      "get": {
+        "tags": [
+          "Agents"
+        ],
+        "summary": "Returns the official publish preview/readiness surface for the saved draft IR.",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PublishPreviewResponse"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "503": {
+            "description": "Service Unavailable"
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "Agents"
+        ],
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "required": true,
+            "schema": {
+              "type": "string",
+              "format": "uuid"
+            }
+          }
+        ],
+        "requestBody": {
+          "content": {
+            "application/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PublishPreviewRequest"
+              }
+            },
+            "text/json": {
+              "schema": {
+                "$ref": "#/components/schemas/PublishPreviewRequest"
+              }
+            },
+            "application/*+json": {
+              "schema": {
+                "$ref": "#/components/schemas/PublishPreviewRequest"
+              }
+            }
+          }
+        },
+        "responses": {
+          "200": {
+            "description": "OK",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/PublishPreviewResponse"
+                }
+              }
+            }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "400": {
+            "description": "Bad Request",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ProblemDetails"
+                }
+              }
+            }
+          },
+          "503": {
+            "description": "Service Unavailable"
+          }
+        }
+      }
+    },
     "/v1/api/agents/{id}/draft/ir": {
       "get": {
         "tags": [
@@ -13085,6 +13209,231 @@
         },
         "additionalProperties": false
       },
+      "PublishPreviewBindingItem": {
+        "type": "object",
+        "properties": {
+          "binding_key": {
+            "type": "string",
+            "nullable": true
+          },
+          "status": {
+            "type": "string",
+            "nullable": true
+          },
+          "required_by_capabilities": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          },
+          "credential_instance_refs": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          },
+          "credential_type_refs": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          }
+        },
+        "additionalProperties": false
+      },
+      "PublishPreviewCapabilityItem": {
+        "type": "object",
+        "properties": {
+          "node_id": {
+            "type": "string",
+            "nullable": true
+          },
+          "capability_ref": {
+            "type": "string",
+            "nullable": true
+          },
+          "capability_version": {
+            "type": "string",
+            "nullable": true
+          },
+          "execution_binding": {
+            "type": "string",
+            "nullable": true
+          },
+          "required_credentials": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          }
+        },
+        "additionalProperties": false
+      },
+      "PublishPreviewDraftDiff": {
+        "type": "object",
+        "properties": {
+          "added_node_ids": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          },
+          "removed_node_ids": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          },
+          "modified_node_ids": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          },
+          "added_capability_refs": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          },
+          "removed_capability_refs": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          },
+          "binding_keys_impacted": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "nullable": true
+          }
+        },
+        "additionalProperties": false
+      },
+      "PublishPreviewIssue": {
+        "type": "object",
+        "properties": {
+          "code": {
+            "type": "string",
+            "nullable": true
+          },
+          "message": {
+            "type": "string",
+            "nullable": true
+          },
+          "severity": {
+            "type": "string",
+            "nullable": true
+          },
+          "path": {
+            "type": "string",
+            "nullable": true
+          },
+          "node_id": {
+            "type": "string",
+            "nullable": true
+          },
+          "hint": {
+            "type": "string",
+            "nullable": true
+          }
+        },
+        "additionalProperties": false
+      },
+      "PublishPreviewRequest": {
+        "type": "object",
+        "properties": {
+          "ir_json": {
+            "nullable": true
+          }
+        },
+        "additionalProperties": false
+      },
+      "PublishPreviewResponse": {
+        "type": "object",
+        "properties": {
+          "agent_id": {
+            "type": "string",
+            "format": "uuid"
+          },
+          "draft_ir_revision": {
+            "type": "string",
+            "nullable": true
+          },
+          "ready": {
+            "type": "boolean"
+          },
+          "validation_result": {
+            "$ref": "#/components/schemas/PublishPreviewValidationResult"
+          },
+          "capabilities": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PublishPreviewCapabilityItem"
+            },
+            "nullable": true
+          },
+          "bindings": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PublishPreviewBindingItem"
+            },
+            "nullable": true
+          },
+          "draft_diff": {
+            "$ref": "#/components/schemas/PublishPreviewDraftDiff"
+          },
+          "blockers": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PublishPreviewIssue"
+            },
+            "nullable": true
+          },
+          "warnings": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PublishPreviewIssue"
+            },
+            "nullable": true
+          }
+        },
+        "additionalProperties": false
+      },
+      "PublishPreviewValidationResult": {
+        "type": "object",
+        "properties": {
+          "valid": {
+            "type": "boolean"
+          },
+          "errors": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PublishPreviewIssue"
+            },
+            "nullable": true
+          },
+          "warnings": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/PublishPreviewIssue"
+            },
+            "nullable": true
+          }
+        },
+        "additionalProperties": false
+      },
       "RejectImprovementCaseRequest": {
         "type": "object",
         "properties": {

package/src/modules/agents.ts

@@ -53,6 +53,58 @@ export interface GraphValidationResponse {
     warnings?: string[];
 }
 
+export interface PublishPreviewIssue {
+    code: string;
+    message: string;
+    severity: string;
+    path?: string;
+    node_id?: string;
+    hint?: string;
+}
+
+export interface PublishPreviewValidationResult {
+    valid: boolean;
+    errors: PublishPreviewIssue[];
+    warnings: PublishPreviewIssue[];
+}
+
+export interface PublishPreviewCapabilityItem {
+    node_id: string;
+    capability_ref: string;
+    capability_version: string;
+    execution_binding: string;
+    required_credentials: string[];
+}
+
+export interface PublishPreviewBindingItem {
+    binding_key: string;
+    status: "bound" | "missing" | "ambiguous";
+    required_by_capabilities: string[];
+    credential_instance_refs: string[];
+    credential_type_refs: string[];
+}
+
+export interface PublishPreviewDraftDiff {
+    added_node_ids: string[];
+    removed_node_ids: string[];
+    modified_node_ids: string[];
+    added_capability_refs: string[];
+    removed_capability_refs: string[];
+    binding_keys_impacted: string[];
+}
+
+export interface PublishPreviewResponse {
+    agent_id: string;
+    draft_ir_revision: string;
+    ready: boolean;
+    validation_result: PublishPreviewValidationResult;
+    capabilities: PublishPreviewCapabilityItem[];
+    bindings: PublishPreviewBindingItem[];
+    draft_diff: PublishPreviewDraftDiff;
+    blockers: PublishPreviewIssue[];
+    warnings: PublishPreviewIssue[];
+}
+
 export interface AgentDraftIrResponse {
     id: string;
     name: string;
@@ -308,6 +360,24 @@ export class AgentsModule {
         });
     }
 
+    async getPublishPreview(
+        agentId: string,
+        irJson?: Record<string, unknown>
+    ): Promise<APIResponse<PublishPreviewResponse>> {
+        if (irJson) {
+            return this.client.POST<PublishPreviewResponse>("/v1/api/agents/{id}/publish-preview", {
+                params: { path: { id: agentId } },
+                body: { ir_json: irJson } as any,
+                headers: this.headers(),
+            });
+        }
+
+        return this.client.GET<PublishPreviewResponse>("/v1/api/agents/{id}/publish-preview", {
+            params: { path: { id: agentId } },
+            headers: this.headers(),
+        });
+    }
+
     // ======================== Draft IR ========================
 
     async getDraftIr(agentId: string): Promise<APIResponse<AgentDraftIrResponse>> {

package/src/modules/runs.ts

@@ -87,6 +87,48 @@ export interface RunEventDto {
     root_operation_id: string;
 }
 
+export interface RunInspectionResponse {
+    run: Record<string, unknown>;
+    replay: Record<string, unknown>;
+    failure: Record<string, unknown>;
+    attempts: Array<Record<string, unknown>>;
+    node_executions: Array<Record<string, unknown>>;
+    events: Array<Record<string, unknown>>;
+}
+
+export interface RunObservabilitySummaryResponse {
+    workspace_id: string;
+    agent_id?: string | null;
+    from?: string | null;
+    to?: string | null;
+    runs_total: number;
+    runs_completed: number;
+    runs_failed: number;
+    node_executions_total: number;
+    node_executions_failed: number;
+    retry_count: number;
+    replay_count: number;
+    handoff_count: number;
+    avg_run_latency_ms: number;
+    p95_run_latency_ms: number;
+    avg_node_latency_ms: number;
+    failure_rate: number;
+    top_error_categories: Array<{
+        error_category: string;
+        count: number;
+    }>;
+}
+
+export interface RunObservabilityCapabilityListResponse {
+    items: Array<Record<string, unknown>>;
+    count: number;
+}
+
+export interface RunObservabilityBindingListResponse {
+    items: Array<Record<string, unknown>>;
+    count: number;
+}
+
 export class RunsModule {
     constructor(private client: RawClient) { }
 
@@ -139,6 +181,12 @@ export class RunsModule {
         });
     }
 
+    async getInspection(runId: string): Promise<APIResponse<RunInspectionResponse>> {
+        return this.client.GET<RunInspectionResponse>("/v1/api/runs/{runId}/inspection", {
+            params: { path: { runId } },
+        });
+    }
+
     /**
      * List runs with optional filters.
      */
@@ -243,6 +291,40 @@ export class RunsModule {
         });
     }
 
+    async getObservabilitySummary(params?: {
+        agent_id?: string;
+        from?: string;
+        to?: string;
+    }): Promise<APIResponse<RunObservabilitySummaryResponse>> {
+        return this.client.GET<RunObservabilitySummaryResponse>("/v1/api/runs/observability/summary", {
+            params: { query: params },
+        });
+    }
+
+    async getObservabilityCapabilities(params?: {
+        agent_id?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<RunObservabilityCapabilityListResponse>> {
+        return this.client.GET<RunObservabilityCapabilityListResponse>("/v1/api/runs/observability/capabilities", {
+            params: { query: params },
+        });
+    }
+
+    async getObservabilityBindings(params?: {
+        agent_id?: string;
+        from?: string;
+        to?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<APIResponse<RunObservabilityBindingListResponse>> {
+        return this.client.GET<RunObservabilityBindingListResponse>("/v1/api/runs/observability/bindings", {
+            params: { query: params },
+        });
+    }
+
     /**
      * Resume a run waiting for human input (HITL).
      * After the run reaches status 'waiting_for_human', use this to provide