@meistrari/agent-sdk 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -1,15 +1,16 @@
 import { VaultFile } from '@meistrari/vault-sdk';
-import { z } from 'zod';
+import { SESSION_STREAM_EVENT_KINDS, sessionStreamEventSchema, executeAgentRequestSchema, executeAgentResponseSchema, updateAgentModelRequestSchema, updateAgentModelResponseSchema, sessionTimelineIdSchema, sessionTimelineResponseSchema } from './schemas.mjs';
+import '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() {
@@ -20,7 +21,7 @@ class DataTokenAuthStrategy {
 }
 class APIKeyAuthStrategy {
   constructor(apiKey) {
-    __publicField(this, "apiKey");
+    __publicField$1(this, "apiKey");
     this.apiKey = apiKey;
   }
   getHeaders() {
@@ -30,6 +31,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);
@@ -37,6 +44,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) {
@@ -52,571 +60,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"
-];
-z.enum(nativeAnthropicModelIds);
-const openrouterModelIds = openrouterCatalog.map((entry) => entry.id);
-const modelSchema = z.enum([
-  ...nativeAnthropicModelIds,
-  ...openrouterModelIds
-]);
-
-const vaultReferenceSchema = z.string().regex(/^vault:\/\/\S+$/, "vaultRef must start with vault:// and cannot contain whitespace");
-const agentInputSchema = z.object({
-  vaultRef: vaultReferenceSchema,
-  filename: z.string().min(1, "Filename is required").max(255, "Filename must be 255 characters or less"),
-  metadata: z.string().max(16384, "Metadata must be 16,384 characters or less").optional()
-}).strict();
-const executeAgentRequestSchema = z.object({
-  sessionId: z.string().uuid().optional(),
-  organizationName: z.string().min(1).max(200).optional(),
-  repository: z.string().min(1).max(200).optional(),
-  ref: z.string().max(200).optional(),
-  message: z.string().min(1).max(8e5).optional(),
-  inputs: z.array(agentInputSchema).optional(),
-  environmentVariables: z.record(z.string(), z.string()).optional(),
-  recover: 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 = z.object({
-  success: z.boolean(),
-  sessionId: z.string().optional(),
-  error: z.string().optional()
-});
-const repositoryNameSchema = z.string().min(1, "Repository is required").max(200, "Repository must be 200 characters or less").regex(/^[\w.-]+$/, "Repository contains unsupported characters");
-const updateAgentModelRequestSchema = z.object({
-  repository: repositoryNameSchema,
-  model: modelSchema,
-  commitMessage: z.string().max(4096, "Commit message must be 4096 characters or less").optional()
-}).strict();
-const updateAgentModelResponseSchema = z.object({
-  success: z.boolean(),
-  organizationName: z.string().optional(),
-  repository: z.string().optional(),
-  branch: z.string().optional(),
-  commitHash: z.string().optional(),
-  model: modelSchema.optional(),
-  providerTemplate: z.string().optional(),
-  templateSynced: z.boolean().optional(),
-  files: z.array(z.string()).optional(),
-  deletedFiles: z.array(z.string()).optional(),
-  error: z.string().optional()
-});
-
-const sessionStatusSchema = z.enum([
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "waiting_messages",
-  "cancelled"
-]);
-const sessionTimelineIdSchema = z.string().min(1, "Session ID is required");
-const sessionTimelineResponseSchema = z.object({
-  sessionId: z.string(),
-  status: z.string(),
-  metrics: z.record(z.string(), z.unknown()),
-  prompt: z.record(z.string(), z.unknown()),
-  spans: z.array(z.record(z.string(), z.unknown()))
-});
-const sessionStatusEventSchema = z.object({
-  kind: z.literal("status"),
-  sessionId: z.string(),
-  status: sessionStatusSchema,
-  error: z.string().optional(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionStepsEventSchema = z.object({
-  kind: z.literal("steps"),
-  sessionId: z.string(),
-  status: sessionStatusSchema,
-  steps: z.array(z.record(z.string(), z.unknown())),
-  nextCursor: z.number().nullable(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionResultEventSchema = z.object({
-  kind: z.literal("result"),
-  sessionId: z.string(),
-  status: z.enum(["completed", "waiting_messages"]),
-  result: z.record(z.string(), z.unknown()),
-  nextCursor: z.number().nullable(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionErrorEventSchema = z.object({
-  kind: z.literal("error"),
-  sessionId: z.string(),
-  error: z.string()
-});
-const sessionTimelineFinalizeEventSchema = z.object({
-  kind: z.literal("timeline-finalize"),
-  sessionId: z.string(),
-  status: sessionStatusSchema,
-  metrics: z.record(z.string(), z.unknown()).nullable().optional(),
-  prompt: z.record(z.string(), z.unknown()).nullable().optional(),
-  spans: z.array(z.record(z.string(), z.unknown())).nullable().optional(),
-  events: z.array(z.record(z.string(), z.unknown())).nullable().optional(),
-  continuation: z.record(z.string(), z.unknown()).nullable().optional(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionStreamEventSchema = 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");
@@ -726,12 +185,19 @@ 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;
@@ -802,4 +268,4 @@ function agentClient(config) {
   return { executeAgent, updateAgentModel, fetchTimeline, streamSession, resolveReference };
 }
 
-export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, agentClient, agentInputSchema, executeAgentRequestSchema, executeAgentResponseSchema, parseSessionStream, sessionStatusSchema, sessionStreamEventSchema, sessionTimelineIdSchema, sessionTimelineResponseSchema, updateAgentModelRequestSchema, updateAgentModelResponseSchema };
+export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, NetworkError, agentClient, isFetchError, isNetworkError, parseSessionStream };