@meistrari/agent-sdk 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -1,17 +1,18 @@
 'use strict';
 
 const vaultSdk = require('@meistrari/vault-sdk');
-const zod = require('zod');
+const schemas = require('./schemas.cjs');
+require('zod');
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class DataTokenAuthStrategy {
   constructor(dataToken) {
-    __publicField(this, "dataToken");
+    __publicField$1(this, "dataToken");
     this.dataToken = dataToken;
   }
   getHeaders() {
@@ -22,7 +23,7 @@ class DataTokenAuthStrategy {
 }
 class APIKeyAuthStrategy {
   constructor(apiKey) {
-    __publicField(this, "apiKey");
+    __publicField$1(this, "apiKey");
     this.apiKey = apiKey;
   }
   getHeaders() {
@@ -32,6 +33,12 @@ class APIKeyAuthStrategy {
   }
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class FetchError extends Error {
   constructor(message, url, method, response) {
     super(message);
@@ -39,6 +46,7 @@ class FetchError extends Error {
     this.url = url;
     this.method = method;
     this.response = response;
+    __publicField(this, "kind", "http");
     this.name = "FetchError";
   }
   static async from(url, method, response) {
@@ -54,571 +62,22 @@ ${text}`,
     );
   }
 }
-
-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"
-];
-zod.z.enum(nativeAnthropicModelIds);
-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"] });
+class NetworkError extends Error {
+  constructor(url, method, cause) {
+    super(`Failed to ${method} ${url}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.url = url;
+    this.method = method;
+    this.cause = cause;
+    __publicField(this, "kind", "network");
+    this.name = "NetworkError";
   }
-});
-const executeAgentResponseSchema = zod.z.object({
-  success: zod.z.boolean(),
-  sessionId: zod.z.string().optional(),
-  error: zod.z.string().optional()
-});
-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 updateAgentModelResponseSchema = zod.z.object({
-  success: zod.z.boolean(),
-  organizationName: zod.z.string().optional(),
-  repository: zod.z.string().optional(),
-  branch: zod.z.string().optional(),
-  commitHash: zod.z.string().optional(),
-  model: modelSchema.optional(),
-  providerTemplate: zod.z.string().optional(),
-  templateSynced: zod.z.boolean().optional(),
-  files: zod.z.array(zod.z.string()).optional(),
-  deletedFiles: zod.z.array(zod.z.string()).optional(),
-  error: zod.z.string().optional()
-});
-
-const sessionStatusSchema = zod.z.enum([
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "waiting_messages",
-  "cancelled"
-]);
-const sessionTimelineIdSchema = zod.z.string().min(1, "Session ID is required");
-const sessionTimelineResponseSchema = zod.z.object({
-  sessionId: zod.z.string(),
-  status: zod.z.string(),
-  metrics: zod.z.record(zod.z.string(), zod.z.unknown()),
-  prompt: zod.z.record(zod.z.string(), zod.z.unknown()),
-  spans: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown()))
-});
-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: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
-  prompt: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
-  spans: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).nullable().optional(),
-  events: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).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"]);
+}
+function isFetchError(error) {
+  return error instanceof FetchError;
+}
+function isNetworkError(error) {
+  return error instanceof NetworkError;
+}
 
 function normalizeStreamBuffer(buffer) {
   return buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
@@ -665,9 +124,9 @@ function getEventKind(event) {
 }
 function parseKnownEvent(event) {
   const eventKind = getEventKind(event);
-  if (!eventKind || !SESSION_STREAM_EVENT_KINDS.has(eventKind))
+  if (!eventKind || !schemas.SESSION_STREAM_EVENT_KINDS.has(eventKind))
     return void 0;
-  const parsed = sessionStreamEventSchema.safeParse(event);
+  const parsed = schemas.sessionStreamEventSchema.safeParse(event);
   if (!parsed.success)
     throw new Error(parsed.error.message);
   return parsed.data;
@@ -728,42 +187,49 @@ function agentClient(config) {
     headers.set("Accept", params.accept ?? "application/json");
     if (params.body !== void 0)
       headers.set("Content-Type", "application/json");
-    const response = await fetch(url, {
-      method: params.method,
-      headers,
-      body: params.body !== void 0 ? JSON.stringify(params.body) : void 0,
-      signal: params.signal
-    });
+    let response;
+    try {
+      response = await fetch(url, {
+        method: params.method,
+        headers,
+        body: params.body !== void 0 ? JSON.stringify(params.body) : void 0,
+        signal: params.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError")
+        throw error;
+      throw new NetworkError(url.toString(), params.method, error);
+    }
     if (!response.ok)
       throw await FetchError.from(url.toString(), params.method, response);
     return response;
   }
   async function executeAgent(input) {
-    const body = executeAgentRequestSchema.parse(input);
+    const body = schemas.executeAgentRequestSchema.parse(input);
     const response = await request({
       method: "POST",
       path: "/v4/agents/execute",
       body
     });
-    return executeAgentResponseSchema.parse(await response.json());
+    return schemas.executeAgentResponseSchema.parse(await response.json());
   }
   async function updateAgentModel(input) {
-    const { repository, ...body } = updateAgentModelRequestSchema.parse(input);
+    const { repository, ...body } = schemas.updateAgentModelRequestSchema.parse(input);
     const response = await request({
       method: "PUT",
       path: `/v4/agents/${encodeURIComponent(repository)}/model`,
       body
     });
-    return updateAgentModelResponseSchema.parse(await response.json());
+    return schemas.updateAgentModelResponseSchema.parse(await response.json());
   }
   async function fetchTimeline(sessionId, options) {
-    const parsedSessionId = sessionTimelineIdSchema.parse(sessionId);
+    const parsedSessionId = schemas.sessionTimelineIdSchema.parse(sessionId);
     const response = await request({
       method: "GET",
       path: `/v4/sessions/${encodeURIComponent(parsedSessionId)}/timeline`,
       signal: options?.signal
     });
-    return sessionTimelineResponseSchema.parse(await response.json());
+    return schemas.sessionTimelineResponseSchema.parse(await response.json());
   }
   async function streamSession(sessionId, options) {
     const response = await request({
@@ -807,14 +273,8 @@ function agentClient(config) {
 exports.APIKeyAuthStrategy = APIKeyAuthStrategy;
 exports.DataTokenAuthStrategy = DataTokenAuthStrategy;
 exports.FetchError = FetchError;
+exports.NetworkError = NetworkError;
 exports.agentClient = agentClient;
-exports.agentInputSchema = agentInputSchema;
-exports.executeAgentRequestSchema = executeAgentRequestSchema;
-exports.executeAgentResponseSchema = executeAgentResponseSchema;
+exports.isFetchError = isFetchError;
+exports.isNetworkError = isNetworkError;
 exports.parseSessionStream = parseSessionStream;
-exports.sessionStatusSchema = sessionStatusSchema;
-exports.sessionStreamEventSchema = sessionStreamEventSchema;
-exports.sessionTimelineIdSchema = sessionTimelineIdSchema;
-exports.sessionTimelineResponseSchema = sessionTimelineResponseSchema;
-exports.updateAgentModelRequestSchema = updateAgentModelRequestSchema;
-exports.updateAgentModelResponseSchema = updateAgentModelResponseSchema;