@meistrari/agent-sdk 0.2.0 → 0.3.0

package/dist/schemas.cjs

@@ -0,0 +1,665 @@
+'use strict';
+
+const zod = require('zod');
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+var openrouterModels = [
+	{
+		id: "openai/gpt-5.5",
+		name: "OpenAI: GPT-5.5",
+		context_length: 1050000,
+		max_completion_tokens: 128000,
+		pricing: {
+			prompt_per_million: 5,
+			completion_per_million: 30,
+			input_cache_read_per_million: 0.5
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_completion_tokens",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"seed",
+			"structured_outputs",
+			"tool_choice",
+			"tools"
+		],
+		modality: "text+image+file->text",
+		description: "GPT-5.5 is OpenAI’s frontier model designed for complex professional workloads, building on GPT-5.4 with stronger reasoning, higher reliability, and improved token efficiency on hard tasks. It features a 1M+ token..."
+	},
+	{
+		id: "openai/gpt-5.4",
+		name: "OpenAI: GPT-5.4",
+		context_length: 1050000,
+		max_completion_tokens: 128000,
+		pricing: {
+			prompt_per_million: 2.5,
+			completion_per_million: 15,
+			input_cache_read_per_million: 0.25
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_completion_tokens",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"seed",
+			"structured_outputs",
+			"tool_choice",
+			"tools"
+		],
+		modality: "text+image+file->text",
+		description: "GPT-5.4 is OpenAI’s latest frontier model, unifying the Codex and GPT lines into a single system. It features a 1M+ token context window (922K input, 128K output) with support for..."
+	},
+	{
+		id: "openai/gpt-5.3-codex",
+		name: "OpenAI: GPT-5.3-Codex",
+		context_length: 400000,
+		max_completion_tokens: 128000,
+		pricing: {
+			prompt_per_million: 1.75,
+			completion_per_million: 14,
+			input_cache_read_per_million: 0.17
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_completion_tokens",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"seed",
+			"structured_outputs",
+			"tool_choice",
+			"tools"
+		],
+		modality: "text+image+file->text",
+		description: "GPT-5.3-Codex is OpenAI’s most advanced agentic coding model, combining the frontier software engineering performance of GPT-5.2-Codex with the broader reasoning and professional knowledge capabilities of GPT-5.2. It achieves state-of-the-art results"
+	},
+	{
+		id: "google/gemini-3.5-flash",
+		name: "Google: Gemini 3.5 Flash",
+		context_length: 1048576,
+		max_completion_tokens: 65536,
+		pricing: {
+			prompt_per_million: 1.5,
+			completion_per_million: 9,
+			input_cache_read_per_million: 0.15
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_p"
+		],
+		modality: "text+image+file+audio+video->text",
+		description: "Gemini 3.5 Flash is a fast multimodal Google model aimed at coding, reasoning, and parallel agent workflows with a Flash-tier cost profile."
+	},
+	{
+		id: "google/gemini-3-flash-preview",
+		name: "Google: Gemini 3 Flash Preview",
+		context_length: 1048576,
+		max_completion_tokens: 65536,
+		pricing: {
+			prompt_per_million: 0.5,
+			completion_per_million: 3,
+			input_cache_read_per_million: 0.05
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_p"
+		],
+		modality: "text+image+file+audio+video->text",
+		description: "Gemini 3 Flash Preview is a high speed, high value thinking model designed for agentic workflows, multi turn chat, and coding assistance. It delivers near Pro level reasoning and tool..."
+	},
+	{
+		id: "google/gemini-3.1-pro-preview",
+		name: "Google: Gemini 3.1 Pro Preview",
+		context_length: 1048576,
+		max_completion_tokens: 65536,
+		pricing: {
+			prompt_per_million: 2,
+			completion_per_million: 12,
+			input_cache_read_per_million: 0.2
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_p"
+		],
+		modality: "text+image+file+audio+video->text",
+		description: "Gemini 3.1 Pro Preview is Google’s frontier reasoning model, delivering enhanced software engineering performance, improved agentic reliability, and more efficient token usage across complex workflows. Building on the multimodal foundation..."
+	},
+	{
+		id: "xiaomi/mimo-v2-pro",
+		name: "Xiaomi: MiMo-V2-Pro",
+		context_length: 1048576,
+		max_completion_tokens: 131072,
+		pricing: {
+			prompt_per_million: 1,
+			completion_per_million: 3,
+			input_cache_read_per_million: 0.2
+		},
+		supported_parameters: [
+			"frequency_penalty",
+			"include_reasoning",
+			"max_tokens",
+			"presence_penalty",
+			"reasoning",
+			"response_format",
+			"stop",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_p"
+		],
+		modality: "text->text",
+		description: "MiMo-V2-Pro is Xiaomi's flagship foundation model, featuring over 1T total parameters and a 1M context length, deeply optimized for agentic scenarios. It is highly adaptable to general agent frameworks like..."
+	},
+	{
+		id: "xiaomi/mimo-v2-omni",
+		name: "Xiaomi: MiMo-V2-Omni",
+		context_length: 262144,
+		max_completion_tokens: 65536,
+		pricing: {
+			prompt_per_million: 0.4,
+			completion_per_million: 2,
+			input_cache_read_per_million: 0.08
+		},
+		supported_parameters: [
+			"frequency_penalty",
+			"include_reasoning",
+			"max_tokens",
+			"presence_penalty",
+			"reasoning",
+			"response_format",
+			"stop",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_p"
+		],
+		modality: "text+image+audio+video->text",
+		description: "MiMo-V2-Omni is a frontier omni-modal model that natively processes image, video, and audio inputs within a unified architecture. It combines strong multimodal perception with agentic capability - visual grounding, multi-step..."
+	},
+	{
+		id: "moonshotai/kimi-k2.5",
+		name: "MoonshotAI: Kimi K2.5",
+		context_length: 262144,
+		max_completion_tokens: 65535,
+		pricing: {
+			prompt_per_million: 0.38,
+			completion_per_million: 1.72,
+			input_cache_read_per_million: 0.19
+		},
+		supported_parameters: [
+			"frequency_penalty",
+			"include_reasoning",
+			"logit_bias",
+			"logprobs",
+			"max_tokens",
+			"min_p",
+			"parallel_tool_calls",
+			"presence_penalty",
+			"reasoning",
+			"repetition_penalty",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_k",
+			"top_logprobs",
+			"top_p"
+		],
+		modality: "text+image->text",
+		description: "Kimi K2.5 is Moonshot AI's native multimodal model, delivering state-of-the-art visual coding capability and a self-directed agent swarm paradigm. Built on Kimi K2 with continued pretraining over approximately 15T mixed..."
+	},
+	{
+		id: "moonshotai/kimi-k2-thinking",
+		name: "MoonshotAI: Kimi K2 Thinking",
+		context_length: 262144,
+		max_completion_tokens: null,
+		pricing: {
+			prompt_per_million: 0.6,
+			completion_per_million: 2.5
+		},
+		supported_parameters: [
+			"frequency_penalty",
+			"include_reasoning",
+			"logit_bias",
+			"max_tokens",
+			"min_p",
+			"presence_penalty",
+			"reasoning",
+			"repetition_penalty",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_k",
+			"top_p"
+		],
+		modality: "text->text",
+		description: "Kimi K2 Thinking is Moonshot AI’s most advanced open reasoning model to date, extending the K2 series into agentic, long-horizon reasoning. Built on the trillion-parameter Mixture-of-Experts (MoE) architecture introduced in..."
+	},
+	{
+		id: "moonshotai/kimi-k2-0905",
+		name: "MoonshotAI: Kimi K2 0905",
+		context_length: 262144,
+		max_completion_tokens: 262144,
+		pricing: {
+			prompt_per_million: 0.4,
+			completion_per_million: 2
+		},
+		supported_parameters: [
+			"frequency_penalty",
+			"logit_bias",
+			"logprobs",
+			"max_tokens",
+			"min_p",
+			"presence_penalty",
+			"repetition_penalty",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_k",
+			"top_logprobs",
+			"top_p"
+		],
+		modality: "text->text",
+		description: "Kimi K2 0905 is the September update of [Kimi K2 0711](moonshotai/kimi-k2). It is a large-scale Mixture-of-Experts (MoE) language model developed by Moonshot AI, featuring 1 trillion total parameters with 32..."
+	},
+	{
+		id: "z-ai/glm-5.1",
+		name: "Z.ai: GLM 5.1",
+		context_length: 202752,
+		max_completion_tokens: 131072,
+		pricing: {
+			prompt_per_million: 1.4,
+			completion_per_million: 4.4,
+			input_cache_read_per_million: 0.26
+		},
+		supported_parameters: [
+			"frequency_penalty",
+			"include_reasoning",
+			"logit_bias",
+			"logprobs",
+			"max_tokens",
+			"min_p",
+			"presence_penalty",
+			"reasoning",
+			"repetition_penalty",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_k",
+			"top_logprobs",
+			"top_p"
+		],
+		modality: "text->text",
+		description: "GLM-5.1 delivers a major leap in coding capability, with particularly significant gains in handling long-horizon tasks. Unlike previous models built around minute-level interactions, GLM-5.1 can work independently and continuously on..."
+	},
+	{
+		id: "z-ai/glm-5v-turbo",
+		name: "Z.ai: GLM 5V Turbo",
+		context_length: 202752,
+		max_completion_tokens: 131072,
+		pricing: {
+			prompt_per_million: 1.2,
+			completion_per_million: 4,
+			input_cache_read_per_million: 0.24
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_p"
+		],
+		modality: "text+image+video->text",
+		description: "GLM-5V-Turbo is Z.ai’s first native multimodal agent foundation model, built for vision-based coding and agent-driven tasks. It natively handles image, video, and text inputs, excels at long-horizon planning, complex coding,..."
+	},
+	{
+		id: "minimax/minimax-m2.7",
+		name: "MiniMax: MiniMax M2.7",
+		context_length: 204800,
+		max_completion_tokens: 131072,
+		pricing: {
+			prompt_per_million: 0.3,
+			completion_per_million: 1.2,
+			input_cache_read_per_million: 0.06
+		},
+		supported_parameters: [
+			"include_reasoning",
+			"max_tokens",
+			"reasoning",
+			"response_format",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_p"
+		],
+		modality: "text->text",
+		description: "MiniMax-M2.7 is a next-generation large language model designed for autonomous, real-world productivity and continuous improvement. Built to actively participate in its own evolution, M2.7 integrates advanced agentic capabilities through multi-agent."
+	},
+	{
+		id: "minimax/minimax-m2.5",
+		name: "MiniMax: MiniMax M2.5",
+		context_length: 196608,
+		max_completion_tokens: 65536,
+		pricing: {
+			prompt_per_million: 0.12,
+			completion_per_million: 0.99,
+			input_cache_read_per_million: 0.06
+		},
+		supported_parameters: [
+			"frequency_penalty",
+			"include_reasoning",
+			"logit_bias",
+			"logprobs",
+			"max_tokens",
+			"min_p",
+			"parallel_tool_calls",
+			"presence_penalty",
+			"reasoning",
+			"reasoning_effort",
+			"repetition_penalty",
+			"response_format",
+			"seed",
+			"stop",
+			"structured_outputs",
+			"temperature",
+			"tool_choice",
+			"tools",
+			"top_k",
+			"top_logprobs",
+			"top_p"
+		],
+		modality: "text->text",
+		description: "MiniMax-M2.5 is a SOTA large language model designed for real-world productivity. Trained in a diverse range of complex real-world digital working environments, M2.5 builds upon the coding expertise of M2.1..."
+	}
+];
+
+const openrouterCatalog = /*@__PURE__*/getDefaultExportFromCjs(openrouterModels);
+
+const nativeAnthropicModelIds = [
+  "claude-sonnet-4-5",
+  "claude-sonnet-4-6",
+  "claude-haiku-4-5",
+  "claude-opus-4-6",
+  "claude-opus-4-7",
+  "claude-opus-4-8"
+];
+const nativeModelSchema = zod.z.enum(nativeAnthropicModelIds);
+const openrouterModelCatalog = openrouterCatalog;
+const openrouterModelIds = openrouterCatalog.map((entry) => entry.id);
+const modelSchema = zod.z.enum([
+  ...nativeAnthropicModelIds,
+  ...openrouterModelIds
+]);
+
+const vaultReferenceSchema = zod.z.string().regex(/^vault:\/\/\S+$/, "vaultRef must start with vault:// and cannot contain whitespace");
+const agentInputSchema = zod.z.object({
+  vaultRef: vaultReferenceSchema,
+  filename: zod.z.string().min(1, "Filename is required").max(255, "Filename must be 255 characters or less"),
+  metadata: zod.z.string().max(16384, "Metadata must be 16,384 characters or less").optional()
+}).strict();
+const executeAgentRequestSchema = zod.z.object({
+  sessionId: zod.z.string().uuid().optional(),
+  organizationName: zod.z.string().min(1).max(200).optional(),
+  repository: zod.z.string().min(1).max(200).optional(),
+  ref: zod.z.string().max(200).optional(),
+  message: zod.z.string().min(1).max(8e5).optional(),
+  inputs: zod.z.array(agentInputSchema).optional(),
+  environmentVariables: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  recover: zod.z.boolean().optional()
+}).strict().superRefine((data, ctx) => {
+  if (!data.sessionId) {
+    if (!data.organizationName) {
+      ctx.addIssue({ code: "custom", message: "organizationName is required for new sessions", path: ["organizationName"] });
+    }
+    if (!data.repository) {
+      ctx.addIssue({ code: "custom", message: "repository is required for new sessions", path: ["repository"] });
+    }
+    if (!data.message) {
+      ctx.addIssue({ code: "custom", message: "message is required for new sessions", path: ["message"] });
+    }
+  } else if (!data.recover && !data.message) {
+    ctx.addIssue({ code: "custom", message: "message is required for session continuations", path: ["message"] });
+  }
+  if (data.recover && !data.sessionId) {
+    ctx.addIssue({ code: "custom", message: "sessionId is required when recover is true", path: ["sessionId"] });
+  }
+});
+const executeAgentSuccessResponseSchema = zod.z.object({
+  success: zod.z.literal(true),
+  sessionId: zod.z.string()
+});
+const executeAgentErrorResponseSchema = zod.z.object({
+  success: zod.z.literal(false),
+  error: zod.z.string()
+});
+const executeAgentResponseSchema = zod.z.discriminatedUnion("success", [
+  executeAgentSuccessResponseSchema,
+  executeAgentErrorResponseSchema
+]);
+const repositoryNameSchema = zod.z.string().min(1, "Repository is required").max(200, "Repository must be 200 characters or less").regex(/^[\w.-]+$/, "Repository contains unsupported characters");
+const updateAgentModelRequestSchema = zod.z.object({
+  repository: repositoryNameSchema,
+  model: modelSchema,
+  commitMessage: zod.z.string().max(4096, "Commit message must be 4096 characters or less").optional()
+}).strict();
+const updateAgentModelSuccessResponseSchema = zod.z.object({
+  success: zod.z.literal(true).describe("Whether the model update succeeded"),
+  organizationName: zod.z.string().optional().describe("Resolved Forgejo organization name"),
+  repository: zod.z.string().optional().describe("Forgejo repository name"),
+  branch: zod.z.string().optional().describe("Branch written to"),
+  commitHash: zod.z.string().optional().describe("Commit hash after update"),
+  model: modelSchema.optional().describe("Configured model after update"),
+  providerTemplate: zod.z.string().optional().describe("Provider template selected from the model prefix"),
+  templateSynced: zod.z.boolean().optional().describe("Whether managed template files were synchronized"),
+  files: zod.z.array(zod.z.string()).optional().describe("Files written by the update"),
+  deletedFiles: zod.z.array(zod.z.string()).optional().describe("Files deleted by the update")
+});
+const updateAgentModelErrorResponseSchema = zod.z.object({
+  success: zod.z.literal(false).describe("Whether the model update succeeded"),
+  error: zod.z.string().describe("Error message if the request failed")
+});
+const updateAgentModelResponseSchema = zod.z.discriminatedUnion("success", [
+  updateAgentModelSuccessResponseSchema,
+  updateAgentModelErrorResponseSchema
+]);
+
+const sessionStatusSchema = zod.z.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "waiting_messages",
+  "cancelled"
+]);
+const sessionTimelineIdSchema = zod.z.string().min(1, "Session ID is required");
+const timelineMetricsSchema = zod.z.object({
+  durationMs: zod.z.number().describe("Total execution duration in milliseconds"),
+  toolCalls: zod.z.number().describe("Total number of tool calls"),
+  apiCalls: zod.z.number().describe("Total number of API calls to the model"),
+  tokensIn: zod.z.number().describe("Total input tokens"),
+  tokensOut: zod.z.number().describe("Total output tokens"),
+  cachedTokens: zod.z.number().describe("Total cached input tokens"),
+  totalCostUsd: zod.z.number().describe("Total cost in USD"),
+  cacheSavingsUsd: zod.z.number().describe("Estimated savings from prompt caching in USD")
+});
+const timelinePromptSchema = zod.z.object({
+  model: zod.z.string().nullable().describe("Model used for the session"),
+  claudeSessionId: zod.z.string().nullable().describe("Claude Code internal session ID"),
+  timestamp: zod.z.number().nullable().describe("Timestamp of session start (epoch ms)"),
+  text: zod.z.string().nullable().describe("Initial user prompt text")
+});
+const timelineToolResultSchema = zod.z.object({
+  output: zod.z.string().describe("Tool execution output"),
+  isError: zod.z.boolean().describe("Whether the tool execution resulted in an error"),
+  durationMs: zod.z.number().describe("Real tool execution duration in milliseconds. Tool calls inside a run_turn may run in parallel, so summing tool durations is not the same as run_turn duration.")
+});
+const timelineRunTurnMetricsSchema = zod.z.object({
+  tokensIn: zod.z.number().describe("Input tokens used by model API responses in this run_turn"),
+  tokensOut: zod.z.number().describe("Output tokens used by model API responses in this run_turn"),
+  cachedTokens: zod.z.number().describe("Cached input tokens used by model API responses in this run_turn"),
+  costUsd: zod.z.number().describe("Estimated model API cost in USD for this run_turn"),
+  toolCallCount: zod.z.number().describe("Number of tool_call events in this run_turn"),
+  apiCallCount: zod.z.number().describe("Number of api_response events in this run_turn")
+});
+const timelineEventSchema = zod.z.object({
+  type: zod.z.enum(["api_response", "tool_call", "text", "thinking", "tool_result"]).describe("Event type. text, api_response, and thinking are point-in-time events; tool_call carries a result duration and tool_result is the lightweight completion marker merged by callId."),
+  relativeTimeMs: zod.z.number().describe("Milliseconds since the beginning of the session_loop, anchored at the first turn"),
+  timestamp: zod.z.number().describe("Absolute timestamp (epoch ms)"),
+  sequenceIndex: zod.z.number().int().nonnegative().describe("Stable chronological order within the events array, used to break ties when multiple events have the same timestamp"),
+  runTurnId: zod.z.string().nullable().describe("ID of the run_turn span this event belongs to"),
+  toolName: zod.z.string().optional().describe("Tool name (e.g. exec_command, Read, Write)"),
+  callId: zod.z.string().optional().describe("Tool call ID for correlating with results"),
+  arguments: zod.z.record(zod.z.string(), zod.z.unknown()).optional().describe("Tool call arguments"),
+  displaySummary: zod.z.string().nullable().optional().describe("Backend-formatted summary for tool_call display, such as file path, command, pattern, URL, or query"),
+  category: zod.z.enum(["file", "shell", "search", "edit", "web", "other"]).optional().describe("Backend-classified tool_call category for UI iconography"),
+  status: zod.z.enum(["success", "failed", "cancelled", "timeout"]).optional().describe("Explicit tool_call status when known"),
+  result: timelineToolResultSchema.optional().describe("Tool execution result"),
+  text: zod.z.string().nullable().optional().describe("Text content for assistant text and thinking events. api_response is a call marker and does not duplicate content blocks."),
+  tokensIn: zod.z.number().optional().describe("Input tokens for api_response events"),
+  tokensOut: zod.z.number().optional().describe("Output tokens for api_response events"),
+  cachedTokens: zod.z.number().optional().describe("Cached input tokens for api_response events"),
+  costUsd: zod.z.number().optional().describe("Estimated cost in USD for api_response events")
+});
+const timelineSpanSchema = zod.z.object({
+  type: zod.z.enum(["session_loop", "session_task_turn", "run_turn", "wait"]).describe("Span type. run_turn represents one model API call until the next model API call and includes thinking plus parallel tool calls."),
+  id: zod.z.string().describe("Unique span identifier"),
+  parentId: zod.z.string().nullable().describe("Parent span ID for hierarchy"),
+  startMs: zod.z.number().describe("Start time relative to session start (ms)"),
+  endMs: zod.z.number().describe("End time relative to session start (ms)"),
+  metrics: timelineRunTurnMetricsSchema.optional().describe("Aggregated metrics present on run_turn spans")
+});
+const sessionTimelineResponseSchema = zod.z.object({
+  sessionId: zod.z.string(),
+  status: zod.z.string(),
+  metrics: timelineMetricsSchema,
+  prompt: timelinePromptSchema,
+  spans: zod.z.array(timelineSpanSchema)
+});
+const sessionStatusEventSchema = zod.z.object({
+  kind: zod.z.literal("status"),
+  sessionId: zod.z.string(),
+  status: sessionStatusSchema,
+  error: zod.z.string().optional(),
+  createdAt: zod.z.number(),
+  updatedAt: zod.z.number()
+});
+const sessionStepsEventSchema = zod.z.object({
+  kind: zod.z.literal("steps"),
+  sessionId: zod.z.string(),
+  status: sessionStatusSchema,
+  steps: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())),
+  nextCursor: zod.z.number().nullable(),
+  createdAt: zod.z.number(),
+  updatedAt: zod.z.number()
+});
+const sessionResultEventSchema = zod.z.object({
+  kind: zod.z.literal("result"),
+  sessionId: zod.z.string(),
+  status: zod.z.enum(["completed", "waiting_messages"]),
+  result: zod.z.record(zod.z.string(), zod.z.unknown()),
+  nextCursor: zod.z.number().nullable(),
+  createdAt: zod.z.number(),
+  updatedAt: zod.z.number()
+});
+const sessionErrorEventSchema = zod.z.object({
+  kind: zod.z.literal("error"),
+  sessionId: zod.z.string(),
+  error: zod.z.string()
+});
+const sessionTimelineFinalizeEventSchema = zod.z.object({
+  kind: zod.z.literal("timeline-finalize"),
+  sessionId: zod.z.string(),
+  status: sessionStatusSchema,
+  metrics: timelineMetricsSchema.nullable().optional(),
+  prompt: timelinePromptSchema.nullable().optional(),
+  spans: zod.z.array(timelineSpanSchema).nullable().optional(),
+  events: zod.z.array(timelineEventSchema).nullable().optional(),
+  continuation: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
+  createdAt: zod.z.number(),
+  updatedAt: zod.z.number()
+});
+const sessionStreamEventSchema = zod.z.discriminatedUnion("kind", [
+  sessionStatusEventSchema,
+  sessionStepsEventSchema,
+  sessionResultEventSchema,
+  sessionTimelineFinalizeEventSchema,
+  sessionErrorEventSchema
+]);
+const SESSION_STREAM_EVENT_KINDS = /* @__PURE__ */ new Set(["status", "steps", "result", "timeline-finalize", "error"]);
+
+exports.SESSION_STREAM_EVENT_KINDS = SESSION_STREAM_EVENT_KINDS;
+exports.agentInputSchema = agentInputSchema;
+exports.executeAgentErrorResponseSchema = executeAgentErrorResponseSchema;
+exports.executeAgentRequestSchema = executeAgentRequestSchema;
+exports.executeAgentResponseSchema = executeAgentResponseSchema;
+exports.executeAgentSuccessResponseSchema = executeAgentSuccessResponseSchema;
+exports.modelSchema = modelSchema;
+exports.nativeAnthropicModelIds = nativeAnthropicModelIds;
+exports.nativeModelSchema = nativeModelSchema;
+exports.openrouterModelCatalog = openrouterModelCatalog;
+exports.openrouterModelIds = openrouterModelIds;
+exports.sessionStatusSchema = sessionStatusSchema;
+exports.sessionStreamEventSchema = sessionStreamEventSchema;
+exports.sessionTimelineIdSchema = sessionTimelineIdSchema;
+exports.sessionTimelineResponseSchema = sessionTimelineResponseSchema;
+exports.timelineEventSchema = timelineEventSchema;
+exports.timelineMetricsSchema = timelineMetricsSchema;
+exports.timelinePromptSchema = timelinePromptSchema;
+exports.timelineRunTurnMetricsSchema = timelineRunTurnMetricsSchema;
+exports.timelineSpanSchema = timelineSpanSchema;
+exports.timelineToolResultSchema = timelineToolResultSchema;
+exports.updateAgentModelErrorResponseSchema = updateAgentModelErrorResponseSchema;
+exports.updateAgentModelRequestSchema = updateAgentModelRequestSchema;
+exports.updateAgentModelResponseSchema = updateAgentModelResponseSchema;
+exports.updateAgentModelSuccessResponseSchema = updateAgentModelSuccessResponseSchema;