@amigo-ai/platform-sdk 0.85.1 → 0.87.0

package/dist/types/generated/api.d.ts

@@ -713,6 +713,80 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/{workspace_id}/agent-definitions": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** List Agent Definitions */
+        get: operations["list_agent_definitions_v1__workspace_id__agent_definitions_get"];
+        put?: never;
+        /** Register Agent Definition */
+        post: operations["register_agent_definition_v1__workspace_id__agent_definitions_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/{workspace_id}/agent-definitions/validate": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Validate Agent Definition
+         * @description Dry-run clamp validation — nothing is stored. 422 with the offending
+         *     paths on failure (the same shape push returns).
+         */
+        post: operations["validate_agent_definition_v1__workspace_id__agent_definitions_validate_post"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/{workspace_id}/agent-definitions/{definition_id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Agent Definition */
+        get: operations["get_agent_definition_v1__workspace_id__agent_definitions__definition_id__get"];
+        put?: never;
+        post?: never;
+        /** Archive Agent Definition */
+        delete: operations["archive_agent_definition_v1__workspace_id__agent_definitions__definition_id__delete"];
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/{workspace_id}/agent-definitions/{definition_id}/versions/{version}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /** Get Agent Definition Version */
+        get: operations["get_agent_definition_version_v1__workspace_id__agent_definitions__definition_id__versions__version__get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/{workspace_id}/agent-runs": {
         parameters: {
             query?: never;
@@ -733,6 +807,26 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/{workspace_id}/agent-runs/harness-context": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Fetch the neutral session-bootstrap context for a service
+         * @description The retrievable CONTEXT edge of the world-model harness: identity + reference instructions, world scope, tool descriptors, guardrails, and the REAL server-enforced write-floor — the byte-identical projection the hosted runner renders from, so a customer's own framework can bootstrap a session against the same world model. PHI-free (the API-run projection carries no scoped entities or rendered caller prose).
+         */
+        get: operations["get_harness_context_v1__workspace_id__agent_runs_harness_context_get"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/{workspace_id}/agent-runs/{run_id}": {
         parameters: {
             query?: never;
@@ -8152,6 +8246,137 @@ export interface components {
             /** Period */
             period?: string | null;
         };
+        /** AgentDefinitionDetail */
+        AgentDefinitionDetail: {
+            /**
+             * Definition Id
+             * Format: uuid
+             */
+            definition_id: string;
+            /**
+             * Framework
+             * @enum {string}
+             */
+            framework: "claude-agent-sdk" | "openai-agents";
+            /** Name */
+            name: string;
+            /**
+             * Status
+             * @enum {string}
+             */
+            status: "active" | "archived";
+            /** Versions */
+            versions: components["schemas"]["AgentDefinitionVersionMeta"][];
+        };
+        /** AgentDefinitionListResponse */
+        AgentDefinitionListResponse: {
+            /** Continuation Token */
+            continuation_token?: unknown;
+            /** Has More */
+            has_more: boolean;
+            /** Items */
+            items: components["schemas"]["AgentDefinitionSummary"][];
+        };
+        /** AgentDefinitionSummary */
+        AgentDefinitionSummary: {
+            /**
+             * Definition Id
+             * Format: uuid
+             */
+            definition_id: string;
+            /**
+             * Framework
+             * @enum {string}
+             */
+            framework: "claude-agent-sdk" | "openai-agents";
+            /** Name */
+            name: string;
+            /**
+             * Status
+             * @enum {string}
+             */
+            status: "active" | "archived";
+        };
+        /** AgentDefinitionVersionDetail */
+        AgentDefinitionVersionDetail: {
+            /** Agent Count */
+            agent_count: number;
+            /** Body */
+            body: {
+                [key: string]: unknown;
+            };
+            /** Body Sha256 */
+            body_sha256: string;
+            /**
+             * Definition Id
+             * Format: uuid
+             */
+            definition_id: string;
+            /**
+             * Framework
+             * @enum {string}
+             */
+            framework: "claude-agent-sdk" | "openai-agents";
+            /** Has Write Tools */
+            has_write_tools: boolean;
+            /** Validator Rev */
+            validator_rev: string;
+            /** Version */
+            version: number;
+        };
+        /** AgentDefinitionVersionMeta */
+        AgentDefinitionVersionMeta: {
+            /** Agent Count */
+            agent_count: number;
+            /** Body Sha256 */
+            body_sha256: string;
+            /** Has Write Tools */
+            has_write_tools: boolean;
+            /** Validator Rev */
+            validator_rev: string;
+            /** Version */
+            version: number;
+        };
+        /**
+         * AgentIdentity
+         * @description Who the agent IS — platform-authored only; ``None`` for native runs
+         *     (a customer's own definition carries its own identity). Named
+         *     ``AgentIdentity`` (not ``Identity``) to avoid colliding with the existing
+         *     ``config.models.Identity`` OpenAPI schema (a same-name collision would
+         *     force-rename that shipped schema — a breaking spec change).
+         */
+        AgentIdentity: {
+            /**
+             * Developed By
+             * @default
+             */
+            developed_by?: string;
+            /**
+             * Entry Actor Name
+             * @default
+             */
+            entry_actor_name?: string;
+            /**
+             * Initial State
+             * @default
+             */
+            initial_state?: string;
+            /**
+             * Instructions
+             * @default
+             */
+            instructions?: string;
+            /**
+             * Name
+             * @default
+             */
+            name?: string;
+            /**
+             * Role
+             * @default
+             */
+            role?: string;
+        };
         /** AgentResponse */
         AgentResponse: {
             /**
@@ -11177,20 +11402,21 @@ export interface components {
         CreateAgentRunRequest: {
             /**
              * Framework
-             * @description Agent framework the run executes on — runs unmodified in the framework's own design.
-             * @enum {string}
+             * @description Framework a PLATFORM run executes on. For a native run the framework comes from the definition.
              */
-            framework: "claude-agent-sdk" | "openai-agents";
+            framework?: ("claude-agent-sdk" | "openai-agents") | null;
             /**
              * Message
              * @description User message the framework agent is invoked with.
              */
             message: string;
+            /** @description Run a native (bring-your-own) agent definition instead of a platform service. */
+            native?: components["schemas"]["NativeRunRef"] | null;
             /**
              * Service Id
-             * Format: uuid
+             * @description Platform-authored run: the service whose pinned config the agent runs.
              */
-            service_id: string;
+            service_id?: string | null;
             /**
              * Timeout S
              * @description Server-side wall-clock budget for the run, in seconds (max 300).
@@ -11198,7 +11424,7 @@ export interface components {
              */
             timeout_s?: number;
             /**
-             * @description Named version set on the service whose pinned config the run uses.
+             * @description Named version set on the service whose pinned config the run uses (platform runs).
              * @default release
              */
             version_set?: components["schemas"]["NameString"];
@@ -15851,6 +16077,26 @@ export interface components {
             /** Name */
             name: string;
         };
+        /** Guardrails */
+        Guardrails: {
+            /**
+             * Global Action Guidelines
+             * @default []
+             */
+            global_action_guidelines?: string[];
+            /**
+             * Global Boundary Constraints
+             * @default []
+             */
+            global_boundary_constraints?: string[];
+            /**
+             * Guardrails
+             * @default []
+             */
+            guardrails?: {
+                [key: string]: unknown;
+            }[];
+        };
         /** HTTPValidationError */
         HTTPValidationError: {
             /** Detail */
@@ -15893,6 +16139,33 @@ export interface components {
             /** Regulatory Basis */
             regulatory_basis: string;
         };
+        /**
+         * HarnessContext
+         * @description The neutral, retrievable session-bootstrap context for ANY framework.
+         */
+        HarnessContext: {
+            /**
+             * Config Fingerprint
+             * @default
+             */
+            config_fingerprint?: string;
+            /**
+             * Context Version
+             * @default 1
+             */
+            context_version?: number;
+            guardrails: components["schemas"]["Guardrails"];
+            identity?: components["schemas"]["AgentIdentity"] | null;
+            runtime: components["schemas"]["Runtime"];
+            /**
+             * Source
+             * @default
+             */
+            source?: string;
+            tools: components["schemas"]["Tools"];
+            world_scope: components["schemas"]["WorldScope"];
+            write_floor: components["schemas"]["WriteFloor"];
+        };
         /** HealFieldRequest */
         HealFieldRequest: {
             /** Context */
@@ -16132,6 +16405,14 @@ export interface components {
              *     bumped the *same* document. Null for manual uploads and snapshot rows.
              */
             source_file_id?: string | null;
+            /**
+             * Source Folder Path
+             * @description Where the file lived within the mapped Drive folder tree (V279) — the
+             *     relative path, folder names joined by ``/`` (e.g. ``clinical/notes``); ``''``
+             *     at the mapped root. Lets the console show the original folder structure. Null
+             *     for manual uploads and snapshot rows.
+             */
+            source_folder_path?: string | null;
             /**
              * Source Type
              * @description Origin of the document this version belongs to — ``manual`` for console
@@ -17590,6 +17871,32 @@ export interface components {
             /** Version */
             version: string;
         };
+        /**
+         * NativeRunRef
+         * @description Run a customer-authored NATIVE agent definition (inc-10): a REGISTERED
+         *     definition by id (``version`` omitted = latest), or an INLINE body for
+         *     dev/playground iteration. The definition's own ``framework`` selects the
+         *     runtime — no top-level ``framework`` needed.
+         */
+        NativeRunRef: {
+            /**
+             * Definition Id
+             * @description Registered definition to run. Omit `version` for the latest.
+             */
+            definition_id?: string | null;
+            /**
+             * Inline
+             * @description Inline definition document (dev/playground). Validated by the platform clamp schema.
+             */
+            inline?: {
+                [key: string]: unknown;
+            } | null;
+            /**
+             * Version
+             * @description Pinned definition version; omit for latest.
+             */
+            version?: number | null;
+        };
         /** NavTimingEvent */
         NavTimingEvent: {
             /**
@@ -20162,6 +20469,44 @@ export interface components {
              */
             status?: "available";
         };
+        /** RegisterAgentDefinitionRequest */
+        RegisterAgentDefinitionRequest: {
+            /**
+             * Body
+             * @description The framework-native definition document (its 'framework' field selects the shape). Validated by the platform clamp schema — a non-whitelisted field is rejected.
+             */
+            body: {
+                [key: string]: unknown;
+            };
+            /** @description Stable slug identifying this definition within the workspace. */
+            name: components["schemas"]["SlugString"];
+        };
+        /** RegisterAgentDefinitionResponse */
+        RegisterAgentDefinitionResponse: {
+            /** Agent Count */
+            agent_count: number;
+            /** Body Sha256 */
+            body_sha256: string;
+            /**
+             * Created
+             * @description False when an identical body was already registered (idempotent push).
+             */
+            created: boolean;
+            /**
+             * Definition Id
+             * Format: uuid
+             */
+            definition_id: string;
+            /**
+             * Framework
+             * @enum {string}
+             */
+            framework: "claude-agent-sdk" | "openai-agents";
+            /** Has Write Tools */
+            has_write_tools: boolean;
+            /** Version */
+            version: number;
+        };
         /**
          * RegisterSchemaRequest
          * @description Create Schema payload (intake-ui-mvp-design.md §5.4, §5.9).
@@ -20876,6 +21221,29 @@ export interface components {
             /** Tags */
             tags?: string[];
         };
+        /** Runtime */
+        Runtime: {
+            /**
+             * Caller Context
+             * @default
+             */
+            caller_context?: string;
+            /**
+             * Channel Kind
+             * @default
+             */
+            channel_kind?: string;
+            /**
+             * Engage Model
+             * @default
+             */
+            engage_model?: string;
+            /**
+             * Language
+             * @default
+             */
+            language?: string;
+        };
         /** SafetyState */
         SafetyState: {
             /**
@@ -24727,6 +25095,23 @@ export interface components {
              */
             type: "tool_call_started";
         };
+        /** ToolDescriptor */
+        ToolDescriptor: {
+            /**
+             * Description
+             * @default
+             */
+            description?: string;
+            /**
+             * Input Schema
+             * @default {}
+             */
+            input_schema?: {
+                [key: string]: unknown;
+            };
+            /** Name */
+            name: string;
+        };
         /** ToolExecuteRequest */
         ToolExecuteRequest: {
             /**
@@ -24852,8 +25237,30 @@ export interface components {
             total_calls?: number;
         };
         /**
-         * TraceAnalysisListItem
-         * @description Compact summary of a trace analysis row for list views.
+         * Tools
+         * @description Discovery hint — the neutral descriptors. NOT the enforcement (the MCP
+         *     edge is; a remote agent discovers live schemas from the server too).
+         */
+        Tools: {
+            /**
+             * Descriptors
+             * @default []
+             */
+            descriptors?: components["schemas"]["ToolDescriptor"][];
+            /**
+             * Read Tool Names
+             * @default []
+             */
+            read_tool_names?: string[];
+            /**
+             * Write Tool Names
+             * @default []
+             */
+            write_tool_names?: string[];
+        };
+        /**
+         * TraceAnalysisListItem
+         * @description Compact summary of a trace analysis row for list views.
          */
         TraceAnalysisListItem: {
             /**
@@ -26405,6 +26812,23 @@ export interface components {
              */
             type: "user_transcript";
         };
+        /** ValidateAgentDefinitionResponse */
+        ValidateAgentDefinitionResponse: {
+            /** Agent Count */
+            agent_count: number;
+            /**
+             * Framework
+             * @enum {string}
+             */
+            framework: "claude-agent-sdk" | "openai-agents";
+            /** Has Write Tools */
+            has_write_tools: boolean;
+            /**
+             * Valid
+             * @constant
+             */
+            valid: true;
+        };
         /** ValidationError */
         ValidationError: {
             /** Context */
@@ -27005,6 +27429,28 @@ export interface components {
             /** Sources */
             sources?: components["schemas"]["SourceBreakdownItem"][];
         };
+        /**
+         * WorldScope
+         * @description The world slice — ids only (the leaf stays I/O-free). This is the
+         *     read/subject scope, NOT the write bound (see ``write_floor``).
+         */
+        WorldScope: {
+            /**
+             * Allow Create
+             * @default false
+             */
+            allow_create?: boolean;
+            /**
+             * Scoped Entity Ids
+             * @default []
+             */
+            scoped_entity_ids?: string[];
+            /**
+             * Workspace Id
+             * Format: uuid
+             */
+            workspace_id: string;
+        };
         /**
          * WrapUpRequest
          * @description Request to record operator intervention wrap-up.
@@ -27028,6 +27474,48 @@ export interface components {
             /** Success */
             success: boolean;
         };
+        /**
+         * WriteFloor
+         * @description The REAL server-enforced write bound (audit G8) — advisory to render;
+         *     the MCP edge enforces it regardless of what a client does.
+         */
+        WriteFloor: {
+            /**
+             * Allow Create
+             * @default false
+             */
+            allow_create?: boolean;
+            /**
+             * Clinical Write Principal
+             * @default provider-only
+             */
+            clinical_write_principal?: string;
+            /**
+             * Clinical Write Scope
+             * @default any-entity-in-workspace
+             */
+            clinical_write_scope?: string;
+            /**
+             * Enforced At
+             * @default mcp-world-tools-edge
+             */
+            enforced_at?: string;
+            /**
+             * Enrichment Write Scope
+             * @default caller-anchor-only
+             */
+            enrichment_write_scope?: string;
+            /**
+             * Requires Entity Anchor
+             * @default true
+             */
+            requires_entity_anchor?: boolean;
+            /**
+             * Unanchored Or Api Key Writes
+             * @default none
+             */
+            unanchored_or_api_key_writes?: string;
+        };
         /** @enum {string} */
         _Access: "read" | "write";
         _DatasetSlug: string;
@@ -29758,6 +30246,207 @@ export interface operations {
             };
         };
     };
+    list_agent_definitions_v1__workspace_id__agent_definitions_get: {
+        parameters: {
+            query?: {
+                framework?: ("claude-agent-sdk" | "openai-agents") | null;
+                include_archived?: boolean;
+                limit?: number;
+                continuation_token?: unknown;
+            };
+            header?: never;
+            path: {
+                workspace_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentDefinitionListResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    register_agent_definition_v1__workspace_id__agent_definitions_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspace_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RegisterAgentDefinitionRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["RegisterAgentDefinitionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    validate_agent_definition_v1__workspace_id__agent_definitions_validate_post: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspace_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["RegisterAgentDefinitionRequest"];
+            };
+        };
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ValidateAgentDefinitionResponse"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    get_agent_definition_v1__workspace_id__agent_definitions__definition_id__get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspace_id: string;
+                definition_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentDefinitionDetail"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    archive_agent_definition_v1__workspace_id__agent_definitions__definition_id__delete: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspace_id: string;
+                definition_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            204: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
+    get_agent_definition_version_v1__workspace_id__agent_definitions__definition_id__versions__version__get: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                workspace_id: string;
+                definition_id: string;
+                version: number;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["AgentDefinitionVersionDetail"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     create_agent_run_v1__workspace_id__agent_runs_post: {
         parameters: {
             query?: never;
@@ -29793,6 +30482,40 @@ export interface operations {
             };
         };
     };
+    get_harness_context_v1__workspace_id__agent_runs_harness_context_get: {
+        parameters: {
+            query: {
+                service_id: string;
+                version_set?: string;
+            };
+            header?: never;
+            path: {
+                workspace_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Successful Response */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HarnessContext"];
+                };
+            };
+            /** @description Validation Error */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["HTTPValidationError"];
+                };
+            };
+        };
+    };
     get_agent_run_v1__workspace_id__agent_runs__run_id__get: {
         parameters: {
             query?: never;