@makaio/contracts 1.0.0-dev-1779051654000

package/dist/agent/schemas/tool-approve.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+/**
+ * Request approval for tool execution.
+ *
+ * Subject: `agent.toolApprove`
+ * Type: Request (RPC)
+ * Emitted when: Agent requires approval before executing a tool
+ *
+ * Response semantics:
+ * - `action: 'allow'`: Approve tool execution
+ *   - `updatedInput`: Optional modified arguments (e.g., user corrected a path)
+ *   - `updatedPermissions`: Optional permission updates (e.g., "always allow" this pattern)
+ * - `action: 'deny'`: Reject tool execution
+ *   - `message`: Required explanation or guidance for the agent
+ *   - `shouldAbort`: If true, stop execution entirely; if false/unset, agent may retry
+ */
+export declare const AgentToolApproveSchema: {
+    request: z.ZodObject<{
+        agentId: z.ZodString;
+        adapterId: z.ZodString;
+        adapterName: z.ZodString;
+        adapterSessionId: z.ZodString;
+        messageId: z.ZodOptional<z.ZodString>;
+        turnId: z.ZodOptional<z.ZodString>;
+        clientId: z.ZodOptional<z.ZodString>;
+        providerConfigId: z.ZodOptional<z.ZodString>;
+        occurredAt: z.ZodOptional<z.ZodNumber>;
+        sessionId: z.ZodString;
+        toolName: z.ZodOptional<z.ZodString>;
+        args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        toolCallId: z.ZodString;
+        reasoning: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    response: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"allow">;
+        updatedInput: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        updatedPermissions: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"deny">;
+        message: z.ZodString;
+        shouldAbort: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>], "action">;
+};
+export type AgentToolApproveRequest = z.infer<typeof AgentToolApproveSchema.request>;
+export type AgentToolApproveResponse = z.infer<typeof AgentToolApproveSchema.response>;
+//# sourceMappingURL=tool-approve.d.ts.map

package/dist/agent/schemas/tool-approve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-approve.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/tool-approve.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;CAsBlC,CAAC;AAEF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,OAAO,CAAC,CAAC;AACrF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,QAAQ,CAAC,CAAC"}

package/dist/agent/schemas/tool.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+/**
+ * Tool use requested by agent.
+ *
+ * Subject: `agent.tool.use`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Agent requests to use a tool
+ */
+export declare const ToolUseSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    messageId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    toolName: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    toolCallId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Tool execution started.
+ *
+ * Subject: `agent.tool.started`
+ * Type: Event (fire-and-forget)
+ * Emitted when: A tool begins execution
+ */
+export declare const ToolStartedSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    messageId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    toolName: z.ZodString;
+    toolCallId: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Tool execution output received.
+ *
+ * Subject: `agent.tool.output`
+ * Type: Event (fire-and-forget)
+ * Emitted when: A tool produces output during execution
+ */
+export declare const ToolOutputSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    messageId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    output: z.ZodString;
+    toolCallId: z.ZodString;
+    toolName: z.ZodOptional<z.ZodString>;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Tool execution completed.
+ *
+ * Subject: `agent.tool.completed`
+ * Type: Event (fire-and-forget)
+ * Emitted when: A tool finishes execution
+ */
+export declare const ToolCompletedSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    messageId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    toolName: z.ZodString;
+    args: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    result: z.ZodUnion<[z.ZodUnion<[z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodString]>, z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>]>;
+    success: z.ZodOptional<z.ZodBoolean>;
+    toolCallId: z.ZodString;
+}, z.core.$strip>;
+export type ToolUse = z.infer<typeof ToolUseSchema>;
+export type ToolStarted = z.infer<typeof ToolStartedSchema>;
+export type ToolOutput = z.infer<typeof ToolOutputSchema>;
+export type ToolCompleted = z.infer<typeof ToolCompletedSchema>;
+//# sourceMappingURL=tool.d.ts.map

package/dist/agent/schemas/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;iBAIxB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;iBAG5B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;iBAK3B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;iBAU9B,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AACpD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAC1D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/agent/schemas/turn.d.ts

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+/**
+ * Agent turn started.
+ *
+ * Subject: `agent.turn.started`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Agent begins processing a user message (after acknowledgment)
+ *
+ * Higher-level abstraction over user_message.acknowledged.
+ * Consumers who don't need merge/supersede details can subscribe to this.
+ */
+export declare const TurnStartedSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    messageId: z.ZodString;
+    content: z.ZodObject<{
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            system: "system";
+            user: "user";
+        }>;
+        blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            content: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                url: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"document">;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                url: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"attachment">;
+            fileName: z.ZodString;
+            filePath: z.ZodString;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                url: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+            displayName: z.ZodOptional<z.ZodString>;
+            attachmentType: z.ZodEnum<{
+                directory: "directory";
+                file: "file";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            content: z.ZodString;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_call">;
+            toolCallId: z.ZodString;
+            name: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_output">;
+            toolCallId: z.ZodString;
+            output: z.ZodString;
+            isError: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>], "type">>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    mergedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type TurnStarted = z.infer<typeof TurnStartedSchema>;
+/**
+ * Agent turn completed.
+ *
+ * Subject: `agent.turn.completed`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Agent finishes processing a turn (always paired with agent.turn.started)
+ *
+ * Fired for ALL outcomes, not just successful completions. Consumers
+ * that only care about success should filter on `outcome === 'completed'`.
+ * For full outcome details (supersededBy, mergedInto), listen to user_message.completed.
+ */
+export declare const TurnCompletedSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    messageId: z.ZodString;
+    message: z.ZodOptional<z.ZodString>;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        error: "error";
+        merged: "merged";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type TurnCompleted = z.infer<typeof TurnCompletedSchema>;
+//# sourceMappingURL=turn.d.ts.map

package/dist/agent/schemas/turn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/turn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;iBAS9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/agent/schemas/usage.d.ts

@@ -0,0 +1,52 @@
+import { z } from 'zod';
+/**
+ * Per-call token usage metrics.
+ *
+ * Subject: `agent.usage`
+ * Type: Event (fire-and-forget)
+ * Emitted when: Usage metrics are available from an AI provider API call
+ *
+ * This event contains delta metrics for a single API call.
+ * For session-level cumulative totals, see `session.usage`.
+ */
+export declare const UsageSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    messageId: z.ZodOptional<z.ZodString>;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    provider: z.ZodString;
+    model: z.ZodString;
+    inputTokens: z.ZodNumber;
+    inputCachedTokens: z.ZodNumber;
+    cacheWriteTokens: z.ZodOptional<z.ZodNumber>;
+    outputTokens: z.ZodNumber;
+    reasoningTokens: z.ZodNumber;
+    totalTokens: z.ZodNumber;
+    costUnits: z.ZodNumber;
+    costUnitType: z.ZodEnum<{
+        requests: "requests";
+        tokens: "tokens";
+    }>;
+    cost: z.ZodOptional<z.ZodNumber>;
+    currency: z.ZodOptional<z.ZodString>;
+    audioInputTokens: z.ZodOptional<z.ZodNumber>;
+    audioOutputTokens: z.ZodOptional<z.ZodNumber>;
+    serviceTier: z.ZodOptional<z.ZodString>;
+    duration: z.ZodOptional<z.ZodNumber>;
+    contextWindow: z.ZodOptional<z.ZodNumber>;
+    quota: z.ZodOptional<z.ZodObject<{
+        type: z.ZodString;
+        limit: z.ZodNumber;
+        used: z.ZodNumber;
+        overage: z.ZodNumber;
+        resetDate: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type Usage = z.infer<typeof UsageSchema>;
+//# sourceMappingURL=usage.d.ts.map

package/dist/agent/schemas/usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usage.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/usage.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BtB,CAAC;AAEH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/agent/schemas/user-message-acknowledged.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+/**
+ * User message acknowledged by agent (processing started).
+ *
+ * Subject: `agent.user_message.acknowledged`
+ * Type: Event (fire-and-forget)
+ * Emitted when: SDK begins processing a user message
+ *
+ * Marks the turn start boundary at agent level.
+ * If messages were merged, `mergedFrom` contains the messageIds that were
+ * folded into this message (their content was combined).
+ */
+export declare const UserMessageAcknowledgedSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    messageId: z.ZodString;
+    mergedFrom: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type UserMessageAcknowledged = z.infer<typeof UserMessageAcknowledgedSchema>;
+//# sourceMappingURL=user-message-acknowledged.d.ts.map

package/dist/agent/schemas/user-message-acknowledged.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-message-acknowledged.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/user-message-acknowledged.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;iBAIxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC"}

package/dist/agent/schemas/user-message-completed.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/**
+ * User message lifecycle completed.
+ *
+ * Subject: `agent.user_message.completed`
+ * Type: Event (fire-and-forget)
+ * Emitted when: A user message's lifecycle ends (any outcome)
+ *
+ * Every messageId from user_message.sent will eventually get a corresponding
+ * user_message.completed event with an explicit outcome.
+ *
+ * For persistence/reconstruction:
+ * - `completed`: Normal flow, agent.complete also emitted
+ * - `superseded`: Partial response may exist, check supersededBy
+ * - `merged`: Content folded into mergedInto message
+ * - `cancelled`: No response expected
+ * - `error`: Check agent.error for details
+ */
+export declare const UserMessageCompletedSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    messageId: z.ZodString;
+    outcome: z.ZodEnum<{
+        cancelled: "cancelled";
+        completed: "completed";
+        error: "error";
+        merged: "merged";
+        rejected: "rejected";
+        superseded: "superseded";
+    }>;
+    supersededBy: z.ZodOptional<z.ZodString>;
+    mergedInto: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type UserMessageCompleted = z.infer<typeof UserMessageCompletedSchema>;
+//# sourceMappingURL=user-message-completed.d.ts.map

package/dist/agent/schemas/user-message-completed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-message-completed.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/user-message-completed.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;iBASrC,CAAC;AAEH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/dist/agent/schemas/user-message-sent.d.ts

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+/**
+ * User message sent to agent.
+ *
+ * Subject: `agent.user_message.sent`
+ * Type: Event (fire-and-forget)
+ * Emitted when: A user message is enqueued for processing
+ *
+ * Captures all user intent including messages that may be superseded.
+ * For persistence, this is the source of truth for user input.
+ */
+export declare const UserMessageSentSchema: z.ZodObject<{
+    agentId: z.ZodString;
+    adapterId: z.ZodString;
+    adapterName: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    adapterSessionId: z.ZodString;
+    turnId: z.ZodOptional<z.ZodString>;
+    clientId: z.ZodOptional<z.ZodString>;
+    providerConfigId: z.ZodOptional<z.ZodString>;
+    occurredAt: z.ZodOptional<z.ZodNumber>;
+    messageId: z.ZodString;
+    content: z.ZodObject<{
+        role: z.ZodEnum<{
+            assistant: "assistant";
+            system: "system";
+            user: "user";
+        }>;
+        blocks: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            content: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"image">;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                url: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"document">;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                url: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"attachment">;
+            fileName: z.ZodString;
+            filePath: z.ZodString;
+            source: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"base64">;
+                data: z.ZodString;
+                mimeType: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"url">;
+                url: z.ZodString;
+                mimeType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>], "type">;
+            displayName: z.ZodOptional<z.ZodString>;
+            attachmentType: z.ZodEnum<{
+                directory: "directory";
+                file: "file";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"reasoning">;
+            content: z.ZodString;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_call">;
+            toolCallId: z.ZodString;
+            name: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"tool_output">;
+            toolCallId: z.ZodString;
+            output: z.ZodString;
+            isError: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>], "type">>;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    deliveryMode: z.ZodEnum<{
+        enqueue: "enqueue";
+        immediate: "immediate";
+        replace: "replace";
+    }>;
+}, z.core.$strip>;
+export type UserMessageSent = z.infer<typeof UserMessageSentSchema>;
+//# sourceMappingURL=user-message-sent.d.ts.map

package/dist/agent/schemas/user-message-sent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-message-sent.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/user-message-sent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAIhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/agent/schemas/validate-model-change.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+/**
+ * RPC subject for validating a mid-session model swap.
+ *
+ * Subject: `agent.validateModelChange`
+ * Type: Request (RPC)
+ * Direction: framework → host
+ *
+ * The framework adapter emits this before replacing a connector. The host
+ * layer (or any registered handler) decides whether the change should proceed
+ * and whether to request an edit-history fork. If no handler is registered
+ * (OSS / headless mode) the framework treats the change as auto-approved.
+ */
+export declare const ValidateModelChangeSchema: {
+    request: z.ZodObject<{
+        agentId: z.ZodString;
+        currentModel: z.ZodString;
+        nextModel: z.ZodString;
+    }, z.core.$strip>;
+    response: z.ZodObject<{
+        proceed: z.ZodBoolean;
+        requestEditHistory: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+};
+export type ValidateModelChangeRequest = z.infer<typeof ValidateModelChangeSchema.request>;
+export type ValidateModelChangeResponse = z.infer<typeof ValidateModelChangeSchema.response>;
+//# sourceMappingURL=validate-model-change.d.ts.map

package/dist/agent/schemas/validate-model-change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-model-change.d.ts","sourceRoot":"","sources":["../../../src/agent/schemas/validate-model-change.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;CAkBrC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,OAAO,CAAC,CAAC;AAC3F,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,QAAQ,CAAC,CAAC"}