@niscorp/signal 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1847 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/signal.ts
+
+// src/utils/estimate-usage.ts
+var CHARS_PER_TOKEN = 4;
+var PER_MESSAGE = 4;
+var lengthOf = (content) => typeof content === "string" ? content.length : JSON.stringify(content ?? "").length;
+var estimateUsage = (messages, content, toolCalls = []) => {
+  let inputTokens = 0;
+  for (const message of messages) inputTokens += PER_MESSAGE + Math.ceil(lengthOf(message.content) / CHARS_PER_TOKEN);
+  const emitted = content + toolCalls.map((call) => `${call.name}${JSON.stringify(call.args)}`).join("");
+  const outputTokens = Math.ceil(emitted.length / CHARS_PER_TOKEN);
+  return { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens, reported: false };
+};
+
+// src/errors.ts
+var ErrorCode = {
+  PROVIDER_NOT_FOUND: "E_PROVIDER_NOT_FOUND",
+  MISSING_API_KEY: "E_MISSING_API_KEY",
+  MISSING_MODEL: "E_MISSING_MODEL",
+  MISSING_SDK: "E_MISSING_SDK",
+  VALIDATION_FAILED: "E_VALIDATION_FAILED",
+  MAX_RETRIES: "E_MAX_RETRIES",
+  MAX_ITERATIONS: "E_MAX_ITERATIONS",
+  PROVIDER_ERROR: "E_PROVIDER_ERROR",
+  TOOL_NOT_FOUND: "E_TOOL_NOT_FOUND",
+  TOOL_EXECUTION: "E_TOOL_EXECUTION",
+  TOOL_VALIDATION: "E_TOOL_VALIDATION",
+  VERB_NOT_SUPPORTED: "E_VERB_NOT_SUPPORTED"
+};
+var SignalError = class extends Error {
+  code;
+  context;
+  constructor(message, code, context) {
+    super(message);
+    this.name = "SignalError";
+    this.code = code;
+    this.context = context;
+  }
+};
+
+// src/registry.ts
+var providerRegistry = {
+  groq: {
+    id: "groq",
+    baseUrl: "https://api.groq.com/openai/v1",
+    envKey: "GROQ_API_KEY",
+    defaultModel: "qwen/qwen3.8-27b",
+    endpoint: {
+      nativeTools: true,
+      nativeJsonMode: true,
+      // Groq validates tool args server-side (tool_use_failed 400s).
+      validatesToolArgs: true,
+      supportsEmbedding: false
+    },
+    adapter: "openai-compatible",
+    // tool_use_failed / json_validate_failed 400s carry the model's
+    // attempt in failed_generation — recover and route it.
+    wire: ["failed-generation"],
+    // Reasoning models stream their trace only when asked to parse it out;
+    // `reasoning_format` is rejected on the non-reasoning ones, which is why
+    // this is opt-in (see reasoningRequest above).
+    reasoningRequest: { reasoning_format: "parsed" }
+  },
+  openai: {
+    id: "openai",
+    baseUrl: "https://api.openai.com/v1",
+    envKey: "OPENAI_API_KEY",
+    defaultModel: "gpt-4o",
+    endpoint: {
+      nativeTools: true,
+      nativeJsonMode: true,
+      validatesToolArgs: false,
+      supportsEmbedding: true
+    },
+    adapter: "openai-compatible",
+    // 4o-era models occasionally emit JSONL where one value was asked
+    // for; the acceptance gate decides, so this can never misfire.
+    wire: ["jsonl-lines"]
+  },
+  openrouter: {
+    id: "openrouter",
+    baseUrl: "https://openrouter.ai/api/v1",
+    envKey: "OPENROUTER_API_KEY",
+    defaultModel: "openai/gpt-4o",
+    endpoint: {
+      nativeTools: true,
+      nativeJsonMode: true,
+      validatesToolArgs: false,
+      supportsEmbedding: false
+    },
+    adapter: "openai-compatible",
+    // OpenRouter unifies reasoning across the models it routes; `enabled` turns
+    // the trace on for those that have one and is ignored by those that don't.
+    reasoningRequest: { reasoning: { enabled: true } }
+  },
+  anthropic: {
+    id: "anthropic",
+    baseUrl: "https://api.anthropic.com/v1",
+    envKey: "ANTHROPIC_API_KEY",
+    defaultModel: "claude-sonnet-4-20250514",
+    endpoint: {
+      nativeTools: true,
+      nativeJsonMode: true,
+      validatesToolArgs: false,
+      supportsEmbedding: false
+    },
+    adapter: "anthropic"
+  },
+  google: {
+    id: "google",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    envKey: "GOOGLE_API_KEY",
+    defaultModel: "gemini-2.0-flash",
+    endpoint: {
+      nativeTools: true,
+      nativeJsonMode: true,
+      validatesToolArgs: false,
+      supportsEmbedding: false
+    },
+    adapter: "google"
+  },
+  typesafe: {
+    id: "typesafe",
+    baseUrl: "https://api.typesafe.ai/v1",
+    envKey: "TYPESAFE_API_KEY",
+    // The moving alias. A caller that records calibration against a model pins
+    // a version (`jev-1.13.0`) with `.model()`.
+    defaultModel: "jev-latest",
+    adapter: "systemone"
+  }
+};
+var modelRegistry = {
+  // ── groq ──
+  "groq/qwen/qwen3.8-27b": {
+    capabilities: { nativeJsonSchema: false, toolsWithStructuredOutput: false, manglesNestedToolArgs: true, multimodal: true },
+    // nested: 3 of 20 trials failed
+    reasoningEfforts: ["none", "default", "low", "medium", "high"],
+    verified: "2026-09-24"
+  },
+  "groq/openai/gpt-oss-120b": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: false, manglesNestedToolArgs: true, multimodal: false },
+    // nested: 1 of 20 trials failed
+    reasoningEfforts: ["low", "medium", "high"],
+    verified: "2026-09-24"
+  },
+  "groq/openai/gpt-oss-20b": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: false, manglesNestedToolArgs: true, multimodal: false },
+    // nested: 6 of 20 trials failed
+    reasoningEfforts: ["low", "medium", "high"],
+    verified: "2026-09-24"
+  },
+  // ── openai ──
+  "openai/gpt-4o": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: true },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: [],
+    verified: "2026-09-24"
+  },
+  "openai/gpt-4o-mini": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: true },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: [],
+    verified: "2026-09-24"
+  },
+  "openai/gpt-4.1-mini": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: true },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: [],
+    verified: "2026-09-24"
+  },
+  // ── openrouter ──
+  "openrouter/qwen/qwen3.8-27b": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: true },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  },
+  "openrouter/openai/gpt-4o": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: true },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  },
+  "openrouter/openai/gpt-4o-mini": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: true },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  },
+  "openrouter/openai/gpt-oss-120b": {
+    capabilities: { nativeJsonSchema: false, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: false },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: ["minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  },
+  "openrouter/z-ai/glm-5.2": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: true, multimodal: false },
+    // nested: 1 of 20 trials failed
+    reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  },
+  "openrouter/openai/gpt-5.6-luna": {
+    capabilities: { nativeJsonSchema: true, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: true },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  },
+  "openrouter/openai/gpt-oss-20b": {
+    capabilities: { nativeJsonSchema: false, toolsWithStructuredOutput: true, manglesNestedToolArgs: false, multimodal: false },
+    // nested: 0 of 20 trials failed
+    reasoningEfforts: ["minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  },
+  "openrouter/meta-llama/llama-3.3-70b-instruct": {
+    capabilities: { nativeJsonSchema: false, toolsWithStructuredOutput: true, manglesNestedToolArgs: true, multimodal: false },
+    // nested: 9 of 20 trials failed
+    reasoningEfforts: ["none", "minimal", "low", "medium", "high", "xhigh", "max"],
+    verified: "2026-09-24"
+  }
+};
+var UNMEASURED_MODEL = {
+  nativeJsonSchema: false,
+  toolsWithStructuredOutput: false,
+  manglesNestedToolArgs: true,
+  multimodal: false
+};
+var modelKey = (provider, model) => `${provider}/${model}`;
+var modelEntry = (provider, model) => modelRegistry[modelKey(provider, model)];
+var resolveApiKey = (envKey, explicitKey) => explicitKey ?? (typeof process !== "undefined" ? process.env?.[envKey] : void 0);
+var chatProviderEntry = (id) => {
+  const entry = providerRegistry[id];
+  return entry === void 0 || entry.adapter === "systemone" ? void 0 : entry;
+};
+
+// src/utils/sdk-loader.ts
+var loadSdk = async (pkg) => {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      pkg
+    );
+    return mod.default ?? mod;
+  } catch {
+    throw new SignalError(
+      `Missing dependency: ${pkg}. Install it with: pnpm add ${pkg}`,
+      ErrorCode.MISSING_SDK,
+      { package: pkg }
+    );
+  }
+};
+
+// src/adapters/openai-compatible.adapter.ts
+var translateContentParts = (parts) => parts.map((part) => {
+  if (part.type === "text") return { type: "text", text: part.text };
+  if (part.type === "image") {
+    const url = part.source.type === "url" ? part.source.url : `data:${part.source.mediaType};base64,${part.source.data}`;
+    return { type: "image_url", image_url: { url } };
+  }
+  return { type: "text", text: "" };
+});
+var translateMessage = (msg) => {
+  switch (msg.role) {
+    case "system":
+      return { role: "system", content: msg.content };
+    case "user":
+      return {
+        role: "user",
+        content: typeof msg.content === "string" ? msg.content : translateContentParts(msg.content)
+      };
+    case "assistant": {
+      const out = { role: "assistant", content: msg.content };
+      if (msg.toolCalls && msg.toolCalls.length > 0) {
+        out.tool_calls = msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: { name: tc.name, arguments: tc.args }
+        }));
+      }
+      return out;
+    }
+    case "tool":
+      return { role: "tool", content: msg.content, tool_call_id: msg.toolCallId };
+    default:
+      return { role: "user", content: "" };
+  }
+};
+var bindAt = (obj, path) => {
+  let parent;
+  let current = obj;
+  for (const key of path) {
+    if (!current || typeof current !== "object") return void 0;
+    parent = current;
+    current = current[key];
+  }
+  return typeof current === "function" ? current.bind(parent) : void 0;
+};
+var createSdkInstance = async (config) => {
+  const Sdk = await loadSdk("openai");
+  const Constructor = typeof Sdk === "function" ? Sdk : Sdk["default"];
+  return new Constructor({
+    apiKey: config.apiKey,
+    baseURL: config.baseUrl,
+    dangerouslyAllowBrowser: typeof globalThis.window !== "undefined"
+  });
+};
+var loadSdkFn = async (config, path, missing, strictClient) => {
+  if (config.client) {
+    const fn2 = bindAt(config.client, path);
+    if (fn2) return fn2;
+    if (strictClient) {
+      throw new SignalError(`Invalid client: expected client.${path.join(".")} to be a function`, ErrorCode.PROVIDER_ERROR);
+    }
+  }
+  const fn = bindAt(await createSdkInstance(config), path);
+  if (!fn) throw new SignalError(missing.message, missing.code);
+  return fn;
+};
+var loadChatCreateFn = (config) => loadSdkFn(config, ["chat", "completions", "create"], { message: "Failed to initialize OpenAI SDK", code: ErrorCode.MISSING_SDK }, true);
+var loadEmbedCreateFn = (config) => loadSdkFn(
+  config,
+  ["embeddings", "create"],
+  { message: "Embedding is not supported by this provider or SDK", code: ErrorCode.PROVIDER_ERROR },
+  false
+);
+var createOpenAICompatibleAdapter = async (config) => {
+  const chatCreate = await loadChatCreateFn(config);
+  const buildParams = (request) => {
+    const params = {
+      model: request.model,
+      messages: request.messages.map(translateMessage)
+    };
+    if (request.responseFormat) {
+      params["response_format"] = request.responseFormat.type === "json_schema" ? { type: "json_schema", json_schema: request.responseFormat.jsonSchema } : { type: "json_object" };
+    }
+    if (request.tools?.length) params["tools"] = request.tools;
+    if (request.toolChoice !== void 0) {
+      params["tool_choice"] = typeof request.toolChoice === "string" ? request.toolChoice : { type: "function", function: { name: request.toolChoice.name } };
+    }
+    if (request.options?.temperature !== void 0) params["temperature"] = request.options.temperature;
+    if (request.options?.maxTokens !== void 0) params["max_completion_tokens"] = request.options.maxTokens;
+    if (request.options?.topP !== void 0) params["top_p"] = request.options.topP;
+    if (request.options?.stopSequences) params["stop"] = request.options.stopSequences;
+    if (request.options?.seed !== void 0) params["seed"] = request.options.seed;
+    if (request.options?.reasoningEffort !== void 0)
+      params["reasoning_effort"] = request.options.reasoningEffort;
+    return params;
+  };
+  const chat = async (request) => {
+    const params = buildParams(request);
+    let completion;
+    try {
+      completion = await chatCreate(params);
+    } catch (error) {
+      throw new SignalError(
+        `Provider error: ${error instanceof Error ? error.message : String(error)}`,
+        ErrorCode.PROVIDER_ERROR,
+        { raw: error }
+      );
+    }
+    const choice = completion.choices?.[0];
+    return {
+      content: choice?.message?.content ?? "",
+      toolCalls: choice?.message?.tool_calls?.map((tc) => ({
+        id: tc.id,
+        name: tc.function.name,
+        args: tc.function.arguments
+      })),
+      usage: {
+        inputTokens: completion.usage?.prompt_tokens ?? 0,
+        outputTokens: completion.usage?.completion_tokens ?? 0,
+        totalTokens: completion.usage?.total_tokens ?? 0
+      },
+      finishReason: choice?.finish_reason ?? "unknown",
+      raw: completion
+    };
+  };
+  async function* chatStream(request, options) {
+    const streamParams = {
+      ...buildParams(request),
+      // Ask for the reasoning trace only when the caller wants reasoning — the
+      // opt-in that keeps `reasoning_format` off a plain Groq call. Stream-only:
+      // the non-stream `chat` path never sees these, so its content is unmoved.
+      ...request.options?.reasoningEffort !== void 0 && config.reasoningRequest !== void 0 ? config.reasoningRequest : {},
+      stream: true,
+      stream_options: { include_usage: true }
+    };
+    let sseStream;
+    try {
+      sseStream = await chatCreate(streamParams, options);
+    } catch (error) {
+      throw new SignalError(
+        `Provider stream error: ${error instanceof Error ? error.message : String(error)}`,
+        ErrorCode.PROVIDER_ERROR,
+        { raw: error }
+      );
+    }
+    try {
+      for await (const chunk of sseStream) {
+        const choice = chunk.choices?.[0];
+        if (choice?.delta?.content) {
+          yield { type: "text", text: choice.delta.content };
+        }
+        const reasoning = choice?.delta?.reasoning ?? choice?.delta?.reasoning_content;
+        if (reasoning) {
+          yield { type: "reasoning", text: reasoning };
+        }
+        if (choice?.delta?.tool_calls) {
+          for (const tc of choice.delta.tool_calls) {
+            yield {
+              type: "tool_call",
+              index: tc.index,
+              id: tc.id,
+              name: tc.function?.name,
+              argsFragment: tc.function?.arguments
+            };
+          }
+        }
+        if (chunk.usage) {
+          yield {
+            type: "usage",
+            inputTokens: chunk.usage.prompt_tokens ?? 0,
+            outputTokens: chunk.usage.completion_tokens ?? 0,
+            totalTokens: chunk.usage.total_tokens ?? 0
+          };
+        }
+        if (choice?.finish_reason) {
+          yield { type: "finish", finishReason: choice.finish_reason };
+        }
+      }
+    } catch (error) {
+      if (error instanceof SignalError) throw error;
+      throw new SignalError(
+        `Provider stream error: ${error instanceof Error ? error.message : String(error)}`,
+        ErrorCode.PROVIDER_ERROR,
+        { raw: error }
+      );
+    }
+  }
+  let cachedEmbedCreate;
+  const embed = async (request) => {
+    if (!cachedEmbedCreate) cachedEmbedCreate = await loadEmbedCreateFn(config);
+    const params = {
+      model: request.model,
+      input: request.input
+    };
+    if (request.dimensions !== void 0) params["dimensions"] = request.dimensions;
+    let response;
+    try {
+      response = await cachedEmbedCreate(params);
+    } catch (error) {
+      throw new SignalError(
+        `Embedding error: ${error instanceof Error ? error.message : String(error)}`,
+        ErrorCode.PROVIDER_ERROR,
+        { raw: error }
+      );
+    }
+    const embeddings = (response.data ?? []).sort((a, b) => a.index - b.index).map((d) => d.embedding);
+    return {
+      embeddings,
+      usage: {
+        inputTokens: response.usage?.prompt_tokens ?? 0,
+        totalTokens: response.usage?.total_tokens ?? 0
+      }
+    };
+  };
+  return { kind: "chat", id: "openai-compatible", chat, chatStream, embed };
+};
+
+// src/adapters/anthropic.adapter.ts
+var createAnthropicAdapter = async (_config) => {
+  throw new SignalError(
+    "Anthropic adapter is not yet implemented. Use openai-compatible with OpenRouter for Anthropic models.",
+    ErrorCode.PROVIDER_ERROR
+  );
+};
+
+// src/adapters/google.adapter.ts
+var createGoogleAdapter = async (_config) => {
+  throw new SignalError(
+    "Google adapter is not yet implemented. Use openai-compatible with OpenRouter for Google models.",
+    ErrorCode.PROVIDER_ERROR
+  );
+};
+var InjectedClientSchema = zod.z.object({
+  fetch: zod.z.custom((value) => typeof value === "function")
+});
+var BodySchema = zod.z.object({
+  model: zod.z.string().optional(),
+  answers: zod.z.unknown(),
+  usage: zod.z.object({ input_tokens: zod.z.number(), output_tokens: zod.z.number() }).optional()
+});
+var sendOf = (client) => {
+  if (client === void 0) return fetch;
+  const injected = InjectedClientSchema.safeParse(client);
+  if (!injected.success) {
+    throw new SignalError("Invalid client: expected client.fetch to be a function", ErrorCode.PROVIDER_ERROR);
+  }
+  return injected.data.fetch;
+};
+var jsonOrText = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+};
+var providerError = (message, raw) => new SignalError(`Provider error: ${message}`, ErrorCode.PROVIDER_ERROR, { raw });
+var createSystemOneAdapter = async (config) => {
+  const send = sendOf(config.client);
+  const url = `${config.baseUrl.replace(/\/+$/, "")}/systemone`;
+  const decide = async (request, options) => {
+    let status;
+    let body;
+    try {
+      const response = await send(url, {
+        method: "POST",
+        headers: { authorization: `Bearer ${config.apiKey}`, "content-type": "application/json" },
+        body: JSON.stringify({ model: request.model, state: request.state, questions: request.questions }),
+        ...options?.signal !== void 0 && { signal: options.signal }
+      });
+      status = response.status;
+      body = jsonOrText(await response.text());
+    } catch (error) {
+      throw providerError(error instanceof Error ? error.message : String(error), error);
+    }
+    if (status < 200 || status >= 300) throw providerError(`HTTP ${status}`, { status, body });
+    const parsed = BodySchema.safeParse(body);
+    if (!parsed.success) return { answers: void 0, raw: body };
+    return {
+      ...parsed.data.model !== void 0 && { model: parsed.data.model },
+      answers: parsed.data.answers,
+      ...parsed.data.usage !== void 0 && {
+        usage: { inputTokens: parsed.data.usage.input_tokens, outputTokens: parsed.data.usage.output_tokens }
+      },
+      raw: body
+    };
+  };
+  return { kind: "decisions", id: "systemone", decide };
+};
+
+// src/transport/protocol.ts
+var RESPOND_DESCRIPTION = "Finish the task. Call this EXACTLY ONCE, ALONE in its own turn, with your final envelope: { response?: string (human-facing text), data (the payload), reasoning?: string (why) }. Calling this ends the run.";
+var EMIT_WITH_TOOLS = (shape, note) => `FINISH PROTOCOL: Use your tools as needed. To finish, your ENTIRE final message must be ONLY the JSON envelope ${shape} \u2014 raw JSON, no prose around it, no code fences.${note} A message without tool calls is treated as your final envelope.`;
+var EMIT_TOOLLESS = (shape, note) => `FINISH PROTOCOL: Your ENTIRE final message must be ONLY the JSON envelope ${shape} \u2014 raw JSON, no prose around it, no code fences.${note}`;
+var NATIVE = (shape, note) => `FINISH PROTOCOL: To finish, reply with no tool calls; your reply is the JSON envelope ${shape}.${note}`;
+var RESPOND = (shape, note) => `FINISH PROTOCOL: To finish, call the \`respond\` tool ALONE in its own turn with the envelope ${shape} as its arguments \u2014 or reply with ONLY that JSON envelope as your entire message.${note}`;
+var envelopeShape = (spec) => {
+  if (!spec.hasData) return '{ "reasoning"?: string, "response": string }';
+  return spec.responseMode === "required" ? '{ "reasoning"?: string, "response": string, "data": <the payload> }' : '{ "reasoning"?: string, "response"?: string, "data": <the payload> }';
+};
+var finishProtocol = (spec) => {
+  const shape = envelopeShape(spec);
+  const note = spec.hasData && spec.injectSchemaDoc ? " `data` must match the OUTPUT SCHEMA above." : "";
+  switch (spec.transport) {
+    case "emit":
+      return spec.hasTools ? EMIT_WITH_TOOLS(shape, note) : EMIT_TOOLLESS(shape, note);
+    case "native":
+      return NATIVE(shape, note);
+    case "respond":
+      return RESPOND(shape, note);
+  }
+};
+var RESPOND_TERMINATION = "You did not finish. Either call the `respond` tool with your final envelope ({ response?, data, reasoning? }), or reply with ONLY that JSON envelope as your entire message \u2014 no surrounding prose.";
+var RESPOND_INVALID = "Your output was invalid: {issues}. Either call `respond`, or reply with ONLY the corrected JSON envelope \u2014 no prose.";
+var CONTENT_TERMINATION = "You did not finish. Reply with ONLY the JSON envelope ({ response?, data, reasoning? }) as your entire message \u2014 no surrounding prose, no code fences.";
+var CONTENT_INVALID = "Your output was invalid: {issues}. Reply with ONLY the corrected JSON envelope as your entire message.";
+var corrections = (transport) => transport === "respond" ? { termination: RESPOND_TERMINATION, invalidOutput: RESPOND_INVALID } : { termination: CONTENT_TERMINATION, invalidOutput: CONTENT_INVALID };
+var bareSchemaPrompt = (jsonSchema) => `OUTPUT SCHEMA: your final reply must be ONLY a JSON value matching this schema \u2014 raw JSON, no prose, no code fences:
+${jsonSchema}`;
+var bareSchemaCorrection = (issues) => `Your output was invalid: ${issues}. Reply with ONLY the corrected JSON value matching the OUTPUT SCHEMA.`;
+var decisionEmulationPrompt = (state) => `Answer every field of the OUTPUT SCHEMA about the STATE below. Each field's description is the question and lists everything you may answer with.
+STATE:
+${state}`;
+var decisionQuestionDescription = (question) => {
+  if (question.type === "choice") return `${question.instructions} Options: ${JSON.stringify(question.criteria)}`;
+  if (question.type === "score") {
+    return `${question.instructions} Answer with the index of the level that fits. Levels, lowest first: ${JSON.stringify(question.criteria)}`;
+  }
+  return question.criteria === void 0 ? question.instructions : `${question.instructions} Meaning: ${JSON.stringify(question.criteria)}`;
+};
+
+// src/decide/gate.ts
+var probability = zod.z.number().min(0).max(1);
+var enumOf = (name, options) => {
+  const [first, ...rest] = options;
+  if (first === void 0) {
+    throw new SignalError(`Question "${name}" offers nothing to answer with`, ErrorCode.VALIDATION_FAILED, { question: name });
+  }
+  return zod.z.enum([first, ...rest]);
+};
+var levelKeysOf = (question) => question.criteria.map((_, level) => String(level));
+var mostProbable = (probabilities) => probabilities.reduce((best, value, level) => value > (probabilities[best] ?? 0) ? level : best, 0);
+var calibratedGate = (name, question) => {
+  if (question.type === "choice") {
+    const option = enumOf(name, Object.keys(question.criteria));
+    return zod.z.object({ choice: option, probabilities: zod.z.record(option, probability), confidence: probability });
+  }
+  if (question.type === "score") {
+    const keys = levelKeysOf(question);
+    const level = enumOf(name, keys);
+    return zod.z.object({
+      score: zod.z.number().min(0).max(keys.length - 1),
+      probabilities: zod.z.record(level, probability),
+      confidence: probability
+    }).transform((answer) => {
+      const probabilities = keys.map((key) => answer.probabilities[key] ?? 0);
+      return { level: mostProbable(probabilities), score: answer.score, probabilities, confidence: answer.confidence };
+    });
+  }
+  return zod.z.object({ noul: probability }).transform((answer) => ({ answer: answer.noul >= 0.5, noul: answer.noul }));
+};
+var uncalibratedField = (name, question) => {
+  const description = decisionQuestionDescription(question);
+  if (question.type === "choice") return enumOf(name, Object.keys(question.criteria)).describe(description);
+  if (question.type === "score") return zod.z.number().int().min(0).max(question.criteria.length - 1).describe(description);
+  return zod.z.boolean().describe(description);
+};
+var uncalibratedDecision = (question, value) => {
+  if (question.type === "choice") return { choice: value };
+  if (question.type === "score") return { level: value };
+  return { answer: value };
+};
+var assertAsked = (questions) => {
+  if (Object.keys(questions).length === 0) {
+    throw new SignalError("decide() needs at least one question", ErrorCode.VALIDATION_FAILED);
+  }
+};
+var answersEvery = (questions, decisions) => Object.keys(questions).every((name) => name in decisions);
+var rejected = (issues, raw) => new SignalError(`Decision rejected: ${issues.join("; ")}`, ErrorCode.VALIDATION_FAILED, { issues, raw });
+var issuesOf = (name, error) => error.issues.map((issue) => `${[name, ...issue.path].join(".")}: ${issue.message}`);
+var assertQuestions = (questions) => {
+  assertAsked(questions);
+  for (const [name, question] of Object.entries(questions)) calibratedGate(name, question);
+};
+var acceptCalibrated = (questions, answers, raw) => {
+  const arrived = zod.z.record(zod.z.string(), zod.z.unknown()).safeParse(answers);
+  if (!arrived.success) throw rejected(["the provider returned no answers"], raw);
+  const decisions = {};
+  const issues = [];
+  for (const [name, question] of Object.entries(questions)) {
+    if (!(name in arrived.data)) {
+      issues.push(`${name}: not answered`);
+      continue;
+    }
+    const gated = calibratedGate(name, question).safeParse(arrived.data[name]);
+    if (gated.success) decisions[name] = gated.data;
+    else issues.push(...issuesOf(name, gated.error));
+  }
+  if (issues.length > 0 || !answersEvery(questions, decisions)) throw rejected(issues, raw);
+  return decisions;
+};
+var uncalibratedSchemaOf = (questions) => zod.z.strictObject(
+  Object.fromEntries(Object.entries(questions).map(([name, question]) => [name, uncalibratedField(name, question)]))
+);
+var acceptUncalibrated = (questions, value, raw) => {
+  const gated = uncalibratedSchemaOf(questions).safeParse(value);
+  if (!gated.success) throw rejected(issuesOf("decisions", gated.error), raw);
+  const decisions = {};
+  for (const [name, question] of Object.entries(questions)) decisions[name] = uncalibratedDecision(question, gated.data[name]);
+  if (!answersEvery(questions, decisions)) throw rejected(["a question went unanswered"], raw);
+  return decisions;
+};
+
+// src/stream/execute-step-stream.ts
+var assembleToolCall = (map, delta) => {
+  let tc = map.get(delta.index);
+  if (!tc) {
+    tc = { id: delta.id ?? "", name: delta.name ?? "", args: "" };
+    map.set(delta.index, tc);
+  }
+  if (delta.id) tc.id = delta.id;
+  if (delta.name) tc.name = delta.name;
+  if (delta.argsFragment) tc.args += delta.argsFragment;
+};
+var buildProviderRequest = (model, request) => {
+  const providerTools = request.tools && request.tools.length > 0 ? request.tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters
+    }
+  })) : void 0;
+  return {
+    model,
+    messages: request.messages.slice(),
+    ...providerTools && { tools: providerTools },
+    ...request.toolChoice !== void 0 && { toolChoice: request.toolChoice },
+    ...request.responseFormat !== void 0 && { responseFormat: request.responseFormat },
+    ...request.options !== void 0 && { options: request.options }
+  };
+};
+async function* executeStepStream(config) {
+  const providerRequest = buildProviderRequest(config.model, config.request);
+  const abortSignal = config.streamOptions?.signal;
+  let contentBuffer = "";
+  let finishReason = "unknown";
+  const assembledToolCalls = /* @__PURE__ */ new Map();
+  let totalUsage = { inputTokens: 0, outputTokens: 0, totalTokens: 0, reported: false };
+  try {
+    for await (const delta of config.adapter.chatStream(providerRequest, abortSignal ? { signal: abortSignal } : void 0)) {
+      if (abortSignal?.aborted) return;
+      switch (delta.type) {
+        case "text":
+          contentBuffer += delta.text;
+          yield { type: "text", text: delta.text };
+          break;
+        // Reasoning is passed straight through and deliberately NOT added to
+        // contentBuffer: it is the model thinking, not its answer.
+        case "reasoning":
+          yield { type: "reasoning", text: delta.text };
+          break;
+        case "tool_call":
+          assembleToolCall(assembledToolCalls, delta);
+          yield {
+            type: "tool_call_delta",
+            index: delta.index,
+            ...delta.id !== void 0 && { id: delta.id },
+            ...delta.name !== void 0 && { name: delta.name },
+            argsText: delta.argsFragment ?? ""
+          };
+          break;
+        case "usage":
+          totalUsage = {
+            inputTokens: delta.inputTokens,
+            outputTokens: delta.outputTokens,
+            totalTokens: delta.totalTokens,
+            reported: true
+          };
+          break;
+        case "finish":
+          finishReason = delta.finishReason;
+          break;
+      }
+    }
+  } catch (error) {
+    if (abortSignal?.aborted) return;
+    throw error;
+  }
+  const toolCalls = [...assembledToolCalls.values()].map((tc) => {
+    let parsed = tc.args;
+    if (typeof tc.args === "string" && tc.args.length > 0) {
+      try {
+        parsed = JSON.parse(tc.args);
+      } catch {
+        parsed = tc.args;
+      }
+    }
+    return { id: tc.id, name: tc.name, args: parsed };
+  });
+  const result = {
+    content: contentBuffer,
+    toolCalls,
+    usage: totalUsage.reported ? totalUsage : estimateUsage(providerRequest.messages, contentBuffer, toolCalls),
+    finishReason,
+    raw: null
+  };
+  yield { type: "done", result };
+}
+
+// src/output-trust.ts
+var asOutput = (content) => content;
+
+// src/run.ts
+var MAX_TOOL_TURNS = 10;
+var ZERO = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+var stringify = (value) => {
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+};
+var toJsonSchema = (schema) => schema["~standard"].jsonSchema.output({ target: "draft-07" });
+var buildRequest = (spec, caps) => {
+  const tools = spec.tools ?? [];
+  if (tools.length > 0 && !caps.nativeTools) {
+    throw new SignalError(
+      "This provider has no native tool calling (capabilities.nativeTools) \u2014 tools are unavailable here.",
+      ErrorCode.PROVIDER_ERROR
+    );
+  }
+  const descriptors = tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    parameters: toJsonSchema(tool.inputSchema)
+  }));
+  const grammarViable = spec.schema !== void 0 && caps.nativeJsonSchema && (tools.length === 0 || caps.toolsWithStructuredOutput);
+  return {
+    ...descriptors.length > 0 && { tools: descriptors },
+    ...spec.schema && { output: { accept: spec.schema } },
+    ...grammarViable && spec.schema ? {
+      responseFormat: {
+        type: "json_schema",
+        jsonSchema: { name: "output", strict: false, schema: toJsonSchema(spec.schema) }
+      }
+    } : spec.schema !== void 0 && caps.nativeJsonMode && tools.length === 0 ? { responseFormat: { type: "json_object" } } : {},
+    ...spec.options && { options: spec.options }
+  };
+};
+var buildMeta = (model, usage, start, retries, toolCalls, raws) => ({
+  model,
+  usage,
+  durationMs: Date.now() - start,
+  retries,
+  toolCalls,
+  provider: { raw: raws.length === 1 ? raws[0] : raws, errors: [] }
+});
+async function* runStream(spec, deps) {
+  const start = Date.now();
+  const requestBase = buildRequest(spec, deps.capabilities);
+  const toolMap = new Map((spec.tools ?? []).map((tool) => [tool.name, tool]));
+  const messages = [...spec.messages];
+  if (spec.schema && requestBase.responseFormat?.type !== "json_schema") {
+    messages.push({ role: "system", content: bareSchemaPrompt(JSON.stringify(toJsonSchema(spec.schema))) });
+  }
+  let usage = ZERO;
+  let retries = 0;
+  const records = [];
+  const raws = [];
+  for (let turn = 0; turn < MAX_TOOL_TURNS + spec.retries; turn += 1) {
+    let result;
+    for await (const event of deps.stepStream({ ...requestBase, messages }, spec.streamOptions)) {
+      if (event.type === "text") yield { type: "text", text: event.text };
+      if (event.type === "done") result = event.result;
+    }
+    if (!result) throw new SignalError("stream ended without a done event", ErrorCode.PROVIDER_ERROR);
+    usage = {
+      inputTokens: usage.inputTokens + result.usage.inputTokens,
+      outputTokens: usage.outputTokens + result.usage.outputTokens,
+      totalTokens: usage.totalTokens + result.usage.totalTokens
+    };
+    raws.push(result.raw);
+    const calls = result.outcome?.kind === "tool_calls" ? result.outcome.calls : spec.schema ? [] : result.toolCalls;
+    if (calls.length > 0) {
+      messages.push({
+        role: "assistant",
+        content: result.content,
+        toolCalls: calls.map((call) => ({ id: call.id, name: call.name, args: stringify(call.args) }))
+      });
+      for (const call of calls) {
+        spec.onToolCall?.(call.name, call.args);
+        yield { type: "tool_start", name: call.name, args: call.args };
+        const tool = toolMap.get(call.name);
+        const parsed = tool?.inputSchema.safeParse(call.args);
+        const started = Date.now();
+        let output2;
+        if (!tool) output2 = `error: unknown tool "${call.name}"`;
+        else if (parsed && !parsed.success) {
+          output2 = `error: input_invalid: ${parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`;
+        } else {
+          try {
+            output2 = await tool.execute(parsed?.data);
+          } catch (cause) {
+            output2 = `error: ${cause instanceof Error ? cause.message : String(cause)}`;
+          }
+        }
+        records.push({ name: call.name, args: call.args, result: output2, durationMs: Date.now() - started });
+        yield { type: "tool_end", name: call.name, result: output2 };
+        messages.push({ role: "tool", toolCallId: call.id, name: call.name, content: stringify(output2) });
+      }
+      continue;
+    }
+    if (!spec.schema) {
+      const history = [...messages, { role: "assistant", content: result.content }];
+      yield {
+        type: "done",
+        response: asOutput(result.content),
+        history,
+        meta: buildMeta(deps.model, usage, start, retries, records, raws)
+      };
+      return;
+    }
+    if (result.outcome?.kind === "output") {
+      const parsed = spec.schema.safeParse(result.outcome.value);
+      if (parsed.success) {
+        const history = [...messages, { role: "assistant", content: result.content }];
+        yield {
+          type: "done",
+          response: parsed.data,
+          history,
+          meta: buildMeta(deps.model, usage, start, retries, records, raws)
+        };
+        return;
+      }
+    }
+    const evidence = result.outcome?.kind === "failed" ? result.outcome.evidence : "output failed schema validation";
+    retries += 1;
+    const error = new SignalError(`Response failed schema validation: ${evidence}`, ErrorCode.VALIDATION_FAILED);
+    spec.onRetry?.(error, retries);
+    if (retries > spec.retries) {
+      yield { type: "error", error, recovered: false };
+      return;
+    }
+    yield { type: "retry", reason: evidence, attempt: retries };
+    if (result.content.length > 0) messages.push({ role: "assistant", content: result.content });
+    messages.push({ role: "system", content: bareSchemaCorrection(evidence) });
+  }
+  throw new SignalError("Max tool iterations reached", ErrorCode.MAX_ITERATIONS);
+}
+var runComplete = async (spec, deps) => {
+  for await (const event of runStream(spec, deps)) {
+    if (event.type === "done") return { response: event.response, history: event.history, meta: event.meta };
+    if (event.type === "error") throw event.error;
+  }
+  throw new SignalError("run ended without a result", ErrorCode.PROVIDER_ERROR);
+};
+
+// src/wire/repair.ts
+var INVISIBLES = /[​‌‍⁠]/g;
+var tryParse = (text) => {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch {
+    return { ok: false };
+  }
+};
+var spanCandidates = (text, open, close) => {
+  const first = text.indexOf(open);
+  if (first < 0) return [];
+  const candidates = [];
+  for (let last = text.lastIndexOf(close); last > first; last = text.lastIndexOf(close, last - 1)) {
+    candidates.push(text.slice(first, last + 1));
+    if (candidates.length >= 8) break;
+  }
+  return candidates;
+};
+var extractJson = (content) => {
+  const cleaned = content.replace(INVISIBLES, "").trim();
+  if (cleaned.length === 0) return { ok: false };
+  const direct = tryParse(cleaned);
+  if (direct.ok) return direct;
+  const fence = cleaned.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+  const body = fence?.[1] !== void 0 ? fence[1].trim() : cleaned;
+  if (body !== cleaned) {
+    const fenced = tryParse(body);
+    if (fenced.ok) return fenced;
+  }
+  for (const candidate of [...spanCandidates(body, "{", "}"), ...spanCandidates(body, "[", "]")]) {
+    const parsed = tryParse(candidate);
+    if (parsed.ok) return parsed;
+  }
+  return { ok: false };
+};
+var repairEscapeDamage = (text) => {
+  const candidates = [];
+  const noQuoteEscapes = text.replace(/\\'/g, "'");
+  if (noQuoteEscapes !== text) candidates.push(noQuoteEscapes);
+  const unescaped = text.replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  if (unescaped !== text) candidates.push(unescaped);
+  return candidates;
+};
+var decodeJsonish = (value) => {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) return value;
+  const direct = tryParse(trimmed);
+  if (direct.ok) return direct.value;
+  for (const repaired of repairEscapeDamage(trimmed)) {
+    const parsed = tryParse(repaired);
+    if (parsed.ok) return parsed.value;
+  }
+  return value;
+};
+var deepDecodeJsonish = (value) => {
+  if (typeof value === "string") {
+    const decoded = decodeJsonish(value);
+    return decoded === value ? value : deepDecodeJsonish(decoded);
+  }
+  if (Array.isArray(value)) return value.map(deepDecodeJsonish);
+  if (typeof value === "object" && value !== null) {
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) out[key] = deepDecodeJsonish(entry);
+    return out;
+  }
+  return value;
+};
+var LITERAL_CHARS = /[0-9a-zA-Z.+\-]/;
+var isCompleteLiteral = (buf) => {
+  if (buf === "true" || buf === "false" || buf === "null") return true;
+  return buf.length > 0 && !Number.isNaN(Number(buf));
+};
+var scan = (text) => {
+  const stack = [];
+  let inString = false;
+  let escape = false;
+  let stringIsValue = false;
+  let literal = "";
+  let boundary;
+  let started = false;
+  const closers = () => [...stack].reverse().map((frame) => frame.type === "obj" ? "}" : "]").join("");
+  const markBoundary = (end) => {
+    boundary = { end, closers: closers() };
+  };
+  const valueDone = (end) => {
+    const top = stack[stack.length - 1];
+    if (top) top.expectingValue = false;
+    markBoundary(end);
+  };
+  const endLiteral = (end) => {
+    if (literal.length === 0) return;
+    if (isCompleteLiteral(literal)) valueDone(end);
+    literal = "";
+  };
+  for (let i = 0; i < text.length; i += 1) {
+    const ch = text[i];
+    if (inString) {
+      if (escape) {
+        escape = false;
+        continue;
+      }
+      if (ch === "\\") {
+        escape = true;
+        continue;
+      }
+      if (ch === '"') {
+        inString = false;
+        if (stringIsValue) valueDone(i + 1);
+      }
+      continue;
+    }
+    if (literal.length > 0 && !LITERAL_CHARS.test(ch)) endLiteral(i);
+    switch (ch) {
+      case "{": {
+        started = true;
+        stack.push({ type: "obj", expectingValue: false });
+        break;
+      }
+      case "[": {
+        started = true;
+        stack.push({ type: "arr", expectingValue: true });
+        break;
+      }
+      case "}":
+      case "]": {
+        if (stack.length === 0) return void 0;
+        stack.pop();
+        valueDone(i + 1);
+        break;
+      }
+      case '"': {
+        const top = stack[stack.length - 1];
+        inString = true;
+        escape = false;
+        stringIsValue = top === void 0 || top.type === "arr" || top.expectingValue;
+        break;
+      }
+      case ":": {
+        const top = stack[stack.length - 1];
+        if (top?.type === "obj") top.expectingValue = true;
+        break;
+      }
+      case ",":
+        break;
+      default: {
+        if (LITERAL_CHARS.test(ch)) {
+          started = true;
+          literal += ch;
+        }
+        break;
+      }
+    }
+  }
+  if (!inString) endLiteral(text.length);
+  if (!started) return void 0;
+  return { openAtEnd: stack.length + (inString ? 1 : 0), ...boundary && { boundary } };
+};
+var closeTruncated = (content) => {
+  const cleaned = content.replace(INVISIBLES, "").trim();
+  if (!cleaned.startsWith("{") && !cleaned.startsWith("[")) return void 0;
+  if (tryParse(cleaned).ok) return void 0;
+  const result = scan(cleaned);
+  if (!result?.boundary || result.openAtEnd === 0) return void 0;
+  const candidate = cleaned.slice(0, result.boundary.end) + result.boundary.closers;
+  return tryParse(candidate).ok ? candidate : void 0;
+};
+var isTruncatedJson = (content) => {
+  const cleaned = content.replace(INVISIBLES, "").trim();
+  if (!cleaned.startsWith("{") && !cleaned.startsWith("[")) return false;
+  if (tryParse(cleaned).ok) return false;
+  return (scan(cleaned)?.openAtEnd ?? 0) > 0;
+};
+
+// src/wire/strategies/failed-generation.ts
+var RECOVERABLE_CODES = /* @__PURE__ */ new Set(["tool_use_failed", "json_validate_failed"]);
+var prop = (obj, key) => obj !== null && typeof obj === "object" ? obj[key] : void 0;
+var unwrap = (error) => error instanceof SignalError ? error.context?.["raw"] ?? error : error;
+var errorCode = (error) => {
+  const direct = prop(error, "code");
+  if (typeof direct === "string") return direct;
+  const nested = prop(prop(error, "error"), "code");
+  return typeof nested === "string" ? nested : void 0;
+};
+var failedGenerationOf = (error) => {
+  const gen = prop(prop(error, "error"), "failed_generation");
+  return typeof gen === "string" && gen.trim().length > 0 ? gen : void 0;
+};
+var asCallShape = (value) => {
+  const name = prop(value, "name");
+  if (typeof name !== "string" || name.length === 0) return void 0;
+  const args = prop(value, "arguments");
+  if (args === void 0) return void 0;
+  if (typeof args === "string") return { name, argsText: args };
+  return { name, args, argsText: JSON.stringify(args) };
+};
+var recover = (error) => {
+  const raw = failedGenerationOf(unwrap(error));
+  if (raw === void 0) return { argsText: "", truncated: false };
+  try {
+    const parsed = JSON.parse(raw);
+    const call = asCallShape(parsed);
+    if (call) return { name: call.name, ...call.args !== void 0 && { args: call.args }, argsText: call.argsText, truncated: false };
+    return { args: parsed, argsText: raw, truncated: false };
+  } catch {
+    const truncated = isTruncatedJson(raw);
+    const closed = closeTruncated(raw);
+    if (closed !== void 0) {
+      try {
+        const call = asCallShape(JSON.parse(closed));
+        if (call) return { name: call.name, ...call.args !== void 0 && { args: call.args }, argsText: call.argsText, truncated };
+      } catch {
+      }
+    }
+    return { argsText: raw, truncated };
+  }
+};
+var failedGeneration = {
+  id: "failed-generation",
+  hook: "error",
+  matches: (error) => {
+    const code = errorCode(unwrap(error));
+    return code !== void 0 && RECOVERABLE_CODES.has(code);
+  },
+  recover
+};
+
+// src/wire/strategies/jsonl-lines.ts
+var jsonlLines = {
+  id: "jsonl-lines",
+  hook: "response",
+  candidates: (content) => {
+    const lines = content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line.startsWith("{") || line.startsWith("["));
+    return lines.length > 1 ? lines.reverse() : [];
+  }
+};
+
+// src/wire/strategies/index.ts
+var REGISTRY = {
+  [failedGeneration.id]: failedGeneration,
+  [jsonlLines.id]: jsonlLines
+};
+var resolveWireStrategies = (ids) => ids.map((id) => {
+  const strategy = REGISTRY[id];
+  if (!strategy) throw new Error(`Unknown wire strategy "${id}" \u2014 known: ${Object.keys(REGISTRY).join(", ")}`);
+  return strategy;
+});
+var errorStrategies = (strategies) => strategies.filter((strategy) => strategy.hook === "error");
+var responseStrategies = (strategies) => strategies.filter((strategy) => strategy.hook === "response");
+var recoverRejection = (strategies, error) => {
+  for (const strategy of errorStrategies(strategies)) {
+    if (!strategy.matches(error)) continue;
+    const rejection = strategy.recover(error);
+    if (rejection) return { strategy: strategy.id, rejection };
+  }
+  return void 0;
+};
+
+// src/wire/router.ts
+var toolTurn = (calls, notes) => ({
+  outcome: { kind: "tool_calls", calls },
+  wire: notes.length > 0 ? { notes } : {}
+});
+var output = (value, rung, note) => ({
+  outcome: { kind: "output", value },
+  wire: note === void 0 ? { rung } : { rung, notes: [note] }
+});
+var failed = (evidence, flags = {}) => ({
+  outcome: {
+    kind: "failed",
+    evidence,
+    ...flags.truncated === true && { truncated: true }
+  },
+  wire: {}
+});
+var tryParse2 = (text) => {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    return { ok: false, why: error instanceof Error ? error.message : String(error) };
+  }
+};
+var whyNotJson = (text) => {
+  const direct = tryParse2(text.trim());
+  return direct.ok ? void 0 : direct.why;
+};
+function* ladder(text, strategies) {
+  const trimmed = text.trim();
+  if (trimmed.length === 0) return;
+  const direct = tryParse2(trimmed);
+  if (direct.ok) yield { value: direct.value, rung: "parse" };
+  const extracted = extractJson(trimmed);
+  if (extracted.ok) yield { value: extracted.value, rung: "extract" };
+  for (const repaired of repairEscapeDamage(trimmed)) {
+    const parsed = tryParse2(repaired);
+    if (parsed.ok) yield { value: parsed.value, rung: "repair-escapes" };
+  }
+  for (const strategy of strategies) {
+    for (const candidateText of strategy.candidates(trimmed)) {
+      const parsed = tryParse2(candidateText);
+      if (parsed.ok) yield { value: parsed.value, rung: strategy.id };
+    }
+  }
+  const closed = closeTruncated(trimmed);
+  if (closed !== void 0) {
+    const parsed = tryParse2(closed);
+    if (parsed.ok) yield { value: parsed.value, rung: "close-truncated" };
+  }
+}
+var firstAccepted = (candidates, accept) => {
+  let nearMiss;
+  for (const candidate of candidates) {
+    const direct = accept.safeParse(candidate.value);
+    if (direct.success) return { winner: candidate };
+    const deep = deepDecodeJsonish(candidate.value);
+    if (deep !== candidate.value && accept.safeParse(deep).success) {
+      return { winner: { value: deep, rung: `${candidate.rung}+deep-decode` } };
+    }
+    nearMiss ??= direct.error.issues.map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`).join("; ");
+  }
+  return { ...nearMiss !== void 0 && { nearMiss } };
+};
+var decodedCall = (call) => ({ ...call, args: decodeJsonish(call.args) });
+var finishAttempt = (call, request) => {
+  if (!request.accept) return void 0;
+  const source = typeof call.args === "string" ? ladder(call.args, request.responseStrategies) : [{ value: call.args, rung: "call-args" }];
+  const { winner, nearMiss } = firstAccepted(source, request.accept);
+  if (winner) {
+    const note = call.name === request.outputTool ? void 0 : `output arrived as a call to undeclared tool "${call.name}"`;
+    return output(winner.value, winner.rung, note);
+  }
+  if (nearMiss !== void 0) {
+    return failed(`the call to "${call.name}" carried an invalid output: ${nearMiss}`);
+  }
+  return void 0;
+};
+var contentEvidence = (content, nearMiss) => {
+  if (nearMiss !== void 0) return nearMiss;
+  const snippet = content.trim().slice(0, 160);
+  if (snippet.length === 0) return "the turn produced no output";
+  const why = whyNotJson(content);
+  return why === void 0 ? `output is not valid JSON \u2014 it began: ${snippet}` : `output is not valid JSON: ${why}. It began: ${snippet}`;
+};
+var contentTurn = (request) => {
+  if (!request.accept) return failed("no acceptance schema for a content turn");
+  const { winner, nearMiss } = firstAccepted(ladder(request.content, request.responseStrategies), request.accept);
+  if (winner) return output(winner.value, winner.rung);
+  return failed(contentEvidence(request.content, nearMiss), {
+    truncated: isTruncatedJson(request.content)
+  });
+};
+var routeResponse = (request) => {
+  const isExit = (call) => call.name === request.outputTool;
+  const domainCalls = request.toolCalls.filter((call) => request.declared.has(call.name) && !isExit(call));
+  const attempts = request.toolCalls.filter((call) => !request.declared.has(call.name) || isExit(call));
+  if (domainCalls.length > 0) {
+    const dropped = attempts.map((call) => `dropped call to "${call.name}" in a mixed turn \u2014 finish attempts must come alone`);
+    return toolTurn(domainCalls.map(decodedCall), dropped);
+  }
+  for (const call of attempts) {
+    const routed = finishAttempt(call, request);
+    if (routed) return routed;
+  }
+  if (attempts.length > 0) {
+    return failed(`called unknown tool(s) ${attempts.map((call) => `"${call.name}"`).join(", ")}`);
+  }
+  return contentTurn(request);
+};
+var recoveredCallCounter = 0;
+var routeRejection = (rejection, request) => {
+  const name = rejection.name;
+  if (name !== void 0 && request.declared.has(name) && name !== request.outputTool) {
+    recoveredCallCounter += 1;
+    const args = rejection.args ?? decodeJsonish(rejection.argsText);
+    return toolTurn([{ id: `recovered_${recoveredCallCounter}`, name, args }], []);
+  }
+  const call = { name: name ?? "", args: rejection.args ?? rejection.argsText };
+  const routed = finishAttempt(call, { ...request});
+  if (routed) {
+    if (routed.outcome.kind === "failed" && rejection.truncated) {
+      return { ...routed, outcome: { ...routed.outcome, truncated: true } };
+    }
+    return routed;
+  }
+  return failed(
+    rejection.argsText.length > 0 ? `provider rejected the attempt${name !== void 0 ? ` (call to unknown tool "${name}")` : ""} and nothing salvageable remained` : "provider rejected the attempt; nothing was recovered",
+    { truncated: rejection.truncated }
+  );
+};
+
+// src/signal.ts
+var resolveProvider = (config) => {
+  if (typeof config.provider === "string") {
+    const entry = providerRegistry[config.provider];
+    if (!entry) throw new SignalError(`Unknown provider: ${config.provider}`, ErrorCode.PROVIDER_NOT_FOUND);
+    const apiKey2 = resolveApiKey(entry.envKey, config.apiKey);
+    if (!apiKey2) throw new SignalError(`Missing API key for ${config.provider}. Set ${entry.envKey} or pass apiKey.`, ErrorCode.MISSING_API_KEY);
+    return {
+      model: config.model ?? entry.defaultModel,
+      apiKey: apiKey2,
+      baseUrl: entry.baseUrl,
+      adapterType: entry.adapter,
+      ...entry.adapter !== "systemone" && entry.reasoningRequest !== void 0 && { reasoningRequest: entry.reasoningRequest }
+    };
+  }
+  const custom = config.provider;
+  const apiKey = custom.apiKey ?? config.apiKey;
+  if (!apiKey) throw new SignalError("Missing API key for custom provider", ErrorCode.MISSING_API_KEY);
+  const model = config.model ?? custom.model;
+  if (!model) throw new SignalError("Missing model for custom provider", ErrorCode.MISSING_MODEL);
+  return { model, apiKey, baseUrl: custom.baseUrl, adapterType: custom.adapter ?? "openai-compatible" };
+};
+var FALLBACK_CAPABILITIES = {
+  nativeTools: false,
+  nativeJsonSchema: false,
+  nativeJsonMode: false,
+  toolsWithStructuredOutput: false,
+  validatesToolArgs: false,
+  manglesNestedToolArgs: false,
+  multimodal: false,
+  supportsEmbedding: false
+};
+var adapterTypeOf = (config) => typeof config.provider === "string" ? providerRegistry[config.provider]?.adapter : config.provider.adapter ?? "openai-compatible";
+var kindOf = (adapterType) => adapterType === "systemone" ? "decisions" : "chat";
+var modelRowOf = (config) => {
+  if (typeof config.provider !== "string") return void 0;
+  const entry = providerRegistry[config.provider];
+  if (entry === void 0) return void 0;
+  const model = config.model ?? entry.defaultModel;
+  return { provider: config.provider, model, row: modelEntry(config.provider, model) };
+};
+var resolveCapabilities = (config) => {
+  if (typeof config.provider === "string") {
+    const entry = providerRegistry[config.provider];
+    if (entry === void 0 || entry.adapter === "systemone") return FALLBACK_CAPABILITIES;
+    return { ...entry.endpoint, ...modelRowOf(config)?.row?.capabilities ?? UNMEASURED_MODEL };
+  }
+  const declared = config.provider.adapter === "systemone" ? {} : config.provider.capabilities;
+  return { ...FALLBACK_CAPABILITIES, ...declared };
+};
+var assertEffort = (config, effort) => {
+  if (effort === void 0) return;
+  const resolved = modelRowOf(config);
+  const row = resolved?.row;
+  if (resolved === void 0 || row === void 0 || row.reasoningEfforts.includes(effort)) return;
+  const accepted = row.reasoningEfforts.length === 0 ? "nothing \u2014 it takes no reasoning effort" : row.reasoningEfforts.join(", ");
+  throw new SignalError(
+    `reasoningEffort "${effort}" is not accepted by ${resolved.provider} ${resolved.model} (accepts: ${accepted}; measured ${row.verified})`,
+    ErrorCode.VALIDATION_FAILED
+  );
+};
+var wireIdsOf = (config) => {
+  const source = typeof config.provider === "string" ? providerRegistry[config.provider] : config.provider;
+  return source === void 0 || source.adapter === "systemone" ? [] : source.wire ?? [];
+};
+var createAdapter = async (resolved, client) => {
+  switch (resolved.adapterType) {
+    case "openai-compatible":
+      return createOpenAICompatibleAdapter({ apiKey: resolved.apiKey, baseUrl: resolved.baseUrl, client, ...resolved.reasoningRequest !== void 0 && { reasoningRequest: resolved.reasoningRequest } });
+    case "anthropic":
+      return createAnthropicAdapter({ apiKey: resolved.apiKey});
+    case "google":
+      return createGoogleAdapter({ apiKey: resolved.apiKey});
+    case "systemone":
+      return createSystemOneAdapter({ apiKey: resolved.apiKey, baseUrl: resolved.baseUrl, client });
+  }
+};
+var buildMessages = (config, input) => {
+  const messages = [];
+  if (config.systemPrompt) messages.push({ role: "system", content: config.systemPrompt });
+  if (config.history) messages.push(...config.history);
+  messages.push({ role: "user", content: input });
+  return messages;
+};
+var recoveredStepResult = (recovered, routed, raw, sent) => ({
+  content: "",
+  toolCalls: routed.outcome.kind === "tool_calls" ? routed.outcome.calls : [],
+  // A rejected generation costs tokens — the provider processed the request and
+  // billed for it — and the 400 body carries none. The prompt is known exactly
+  // and the model's attempt is in the rejection, so this is countable rather
+  // than lost. Marked unreported, because it is a reckoning.
+  usage: estimateUsage(sent, recovered.rejection.argsText, routed.outcome.kind === "tool_calls" ? routed.outcome.calls : []),
+  finishReason: "error_recovered",
+  raw,
+  outcome: routed.outcome,
+  wire: {
+    ...routed.wire,
+    recovered: {
+      strategy: recovered.strategy,
+      ...recovered.rejection.name !== void 0 && { name: recovered.rejection.name },
+      truncated: recovered.rejection.truncated
+    }
+  }
+});
+var createSignalFromConfig = (config) => {
+  let cachedAdapter;
+  let cachedAdapterKey;
+  const wireStrategies = resolveWireStrategies(wireIdsOf(config));
+  assertEffort(config, config.options?.reasoningEffort);
+  const getAdapter = async () => {
+    const resolved = resolveProvider(config);
+    const key = `${resolved.adapterType}:${resolved.baseUrl}:${resolved.apiKey}`;
+    if (cachedAdapter && cachedAdapterKey === key) return cachedAdapter;
+    cachedAdapter = await createAdapter(resolved, config.client);
+    cachedAdapterKey = key;
+    return cachedAdapter;
+  };
+  const getChatAdapter = async (verb) => {
+    const adapter = await getAdapter();
+    if (adapter.kind === "chat") return adapter;
+    throw new SignalError(
+      `${verb}() is not available on a decision provider \u2014 it answers decide() and generates no text`,
+      ErrorCode.VERB_NOT_SUPPORTED,
+      { verb, adapter: adapter.id }
+    );
+  };
+  const fork = (override) => createSignalFromConfig({ ...config, ...override });
+  const step = async (request) => {
+    const adapter = await getChatAdapter("step");
+    const resolved = resolveProvider(config);
+    const messages = request.messages.slice();
+    const providerTools = request.tools && request.tools.length > 0 ? request.tools.map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    })) : void 0;
+    const providerRequest = {
+      model: resolved.model,
+      messages,
+      ...providerTools && { tools: providerTools },
+      ...request.toolChoice !== void 0 && { toolChoice: request.toolChoice },
+      ...request.responseFormat !== void 0 && { responseFormat: request.responseFormat },
+      // The client's own options are the floor; a request may override them
+      // field by field. `complete`/`stream` already run on config.options —
+      // step used to drop them, so a configured client behaved differently
+      // depending on which door the caller came through.
+      ...(config.options !== void 0 || request.options !== void 0) && {
+        options: { ...config.options, ...request.options }
+      }
+    };
+    assertEffort(config, providerRequest.options?.reasoningEffort);
+    const declared = new Set((request.tools ?? []).map((tool) => tool.name));
+    let response;
+    try {
+      response = await adapter.chat(providerRequest);
+    } catch (error) {
+      const recovered = recoverRejection(wireStrategies, error);
+      if (!recovered) throw error;
+      const routed2 = routeRejection(recovered.rejection, {
+        declared,
+        ...request.output && { accept: request.output.accept },
+        ...request.output?.outputTool !== void 0 && { outputTool: request.output.outputTool },
+        responseStrategies: responseStrategies(wireStrategies)
+      });
+      return recoveredStepResult(recovered, routed2, error, providerRequest.messages);
+    }
+    const toolCalls = (response.toolCalls ?? []).map((call) => {
+      let parsed = call.args;
+      if (typeof call.args === "string") {
+        try {
+          parsed = JSON.parse(call.args);
+        } catch {
+          parsed = call.args;
+        }
+      }
+      return { id: call.id, name: call.name, args: parsed };
+    });
+    const result = {
+      content: response.content,
+      toolCalls,
+      // The non-streaming body always carries usage, so a zero here is a real
+      // zero rather than a missing frame.
+      usage: { ...response.usage, reported: true },
+      finishReason: response.finishReason,
+      raw: response.raw
+    };
+    if (!request.output) return result;
+    const routed = routeResponse({
+      content: result.content,
+      toolCalls: result.toolCalls,
+      declared,
+      accept: request.output.accept,
+      ...request.output.outputTool !== void 0 && { outputTool: request.output.outputTool },
+      responseStrategies: responseStrategies(wireStrategies)
+    });
+    return { ...result, outcome: routed.outcome, wire: routed.wire };
+  };
+  const stepStream = (request, streamOptions) => {
+    const run = async function* () {
+      const adapter = await getChatAdapter("stepStream");
+      const resolved = resolveProvider(config);
+      const declared = new Set((request.tools ?? []).map((tool) => tool.name));
+      const merged = config.options !== void 0 || request.options !== void 0 ? { ...request, options: { ...config.options, ...request.options } } : request;
+      assertEffort(config, merged.options?.reasoningEffort);
+      try {
+        for await (const event of executeStepStream({
+          adapter,
+          model: resolved.model,
+          request: merged,
+          ...streamOptions && { streamOptions }
+        })) {
+          if (event.type === "done" && request.output) {
+            const routed = routeResponse({
+              content: event.result.content,
+              toolCalls: event.result.toolCalls,
+              declared,
+              accept: request.output.accept,
+              ...request.output.outputTool !== void 0 && { outputTool: request.output.outputTool },
+              responseStrategies: responseStrategies(wireStrategies)
+            });
+            yield { type: "done", result: { ...event.result, outcome: routed.outcome, wire: routed.wire } };
+            continue;
+          }
+          yield event;
+        }
+      } catch (error) {
+        const recovered = recoverRejection(wireStrategies, error);
+        if (!recovered) throw error;
+        const routed = routeRejection(recovered.rejection, {
+          declared,
+          ...request.output && { accept: request.output.accept },
+          ...request.output?.outputTool !== void 0 && { outputTool: request.output.outputTool },
+          responseStrategies: responseStrategies(wireStrategies)
+        });
+        yield { type: "done", result: recoveredStepResult(recovered, routed, error, request.messages) };
+      }
+    };
+    return run();
+  };
+  const decideCalibrated = async (adapter, model, request, started) => {
+    const response = await adapter.decide(
+      { model, state: request.state, questions: request.questions },
+      request.options?.signal !== void 0 ? { signal: request.options.signal } : void 0
+    );
+    const decisions = acceptCalibrated(request.questions, response.answers, response.raw);
+    const inputTokens = response.usage?.inputTokens ?? 0;
+    const outputTokens = response.usage?.outputTokens ?? 0;
+    return {
+      calibrated: true,
+      decisions,
+      meta: {
+        model: response.model ?? model,
+        usage: { inputTokens, outputTokens, totalTokens: inputTokens + outputTokens, reported: response.usage !== void 0 },
+        durationMs: Date.now() - started,
+        provider: { raw: response.raw }
+      }
+    };
+  };
+  const decideEmulated = async (model, request, started) => {
+    const state = typeof request.state === "string" ? request.state : JSON.stringify(request.state);
+    const result = await runComplete(
+      {
+        messages: [{ role: "user", content: decisionEmulationPrompt(state) }],
+        schema: uncalibratedSchemaOf(request.questions),
+        tools: void 0,
+        retries: config.retries ?? 2,
+        options: config.options,
+        ...request.options?.signal !== void 0 && { streamOptions: { signal: request.options.signal } }
+      },
+      { stepStream, model, capabilities: resolveCapabilities(config) }
+    );
+    return {
+      calibrated: false,
+      decisions: acceptUncalibrated(request.questions, result.response, result.meta.provider.raw),
+      meta: {
+        model: result.meta.model,
+        // complete() sums what providers reported with what it had to estimate
+        // and does not say which, so this total cannot be vouched for as measured.
+        usage: { ...result.meta.usage, reported: false },
+        durationMs: Date.now() - started,
+        provider: { raw: result.meta.provider.raw }
+      }
+    };
+  };
+  return {
+    // Builder methods
+    apiKey: (key) => fork({ apiKey: key }),
+    model: (m) => fork({ model: m }),
+    systemPrompt: (prompt) => fork({ systemPrompt: prompt }),
+    history: (msgs) => fork({ history: msgs }),
+    schema: (s) => fork({ schema: s }),
+    tools: (t) => fork({ tools: t }),
+    retries: (count) => fork({ retries: count }),
+    options: (opts) => fork({ options: { ...config.options, ...opts } }),
+    onRetry: (handler) => fork({ onRetry: handler }),
+    onToolCall: (handler) => fork({ onToolCall: handler }),
+    describe: () => {
+      if (typeof config.provider === "string") {
+        const entry = providerRegistry[config.provider];
+        return {
+          provider: config.provider,
+          model: config.model ?? entry?.defaultModel,
+          kind: kindOf(adapterTypeOf(config)),
+          capabilities: resolveCapabilities(config),
+          modelKnown: modelRowOf(config)?.row !== void 0
+        };
+      }
+      return {
+        provider: config.provider.baseUrl,
+        model: config.model ?? config.provider.model,
+        kind: kindOf(adapterTypeOf(config)),
+        capabilities: resolveCapabilities(config),
+        modelKnown: false
+      };
+    },
+    // Execution — thin wrappers over the step core (src/complete.ts).
+    complete: async (input) => runComplete(
+      {
+        messages: buildMessages(config, input),
+        schema: config.schema,
+        tools: config.tools,
+        retries: config.retries ?? 2,
+        options: config.options,
+        onRetry: config.onRetry,
+        onToolCall: config.onToolCall
+      },
+      { stepStream, model: resolveProvider(config).model, capabilities: resolveCapabilities(config) }
+    ),
+    stream: (input, streamOptions) => runStream(
+      {
+        messages: buildMessages(config, input),
+        schema: config.schema,
+        tools: config.tools,
+        retries: config.retries ?? 2,
+        options: config.options,
+        streamOptions,
+        onRetry: config.onRetry,
+        onToolCall: config.onToolCall
+      },
+      { stepStream, model: resolveProvider(config).model, capabilities: resolveCapabilities(config) }
+    ),
+    // ─── Low-level primitives — the execution core itself ────
+    step,
+    stepStream,
+    // ─── Embedding ────────────────────────────────────────────
+    embed: (async (input, options) => {
+      const adapter = await getChatAdapter("embed");
+      if (!adapter.embed) {
+        throw new SignalError("This provider does not support embedding", ErrorCode.PROVIDER_ERROR);
+      }
+      const resolved = resolveProvider(config);
+      const response = await adapter.embed({
+        model: resolved.model,
+        input,
+        dimensions: options?.dimensions
+      });
+      options?.onUsage?.(response.usage, resolved.model);
+      if (typeof input === "string") {
+        const vector = response.embeddings[0];
+        if (!vector) throw new SignalError("No embedding returned", ErrorCode.PROVIDER_ERROR);
+        return vector;
+      }
+      return response.embeddings;
+    }),
+    // ─── Decisions ────────────────────────────────────────────
+    decide: async (request) => {
+      assertQuestions(request.questions);
+      const started = Date.now();
+      const adapter = await getAdapter();
+      const model = resolveProvider(config).model;
+      return adapter.kind === "decisions" ? decideCalibrated(adapter, model, request, started) : decideEmulated(model, request, started);
+    },
+    // ─── Low-level: token counting (heuristic) ───────────────
+    count: async (input) => {
+      const CHARS_PER_TOKEN2 = 4;
+      if (typeof input === "string") {
+        return Math.ceil(input.length / CHARS_PER_TOKEN2);
+      }
+      let total = 0;
+      for (const msg of input) {
+        total += 4;
+        if (typeof msg.content === "string") {
+          total += Math.ceil(msg.content.length / CHARS_PER_TOKEN2);
+          continue;
+        }
+        for (const part of msg.content) {
+          if (part.type === "text") {
+            total += Math.ceil(part.text.length / CHARS_PER_TOKEN2);
+          } else {
+            total += 256;
+          }
+        }
+      }
+      return total;
+    }
+  };
+};
+var createSignal = (provider, options) => createSignalFromConfig({ provider, ...options });
+
+// src/tools/define-tool.ts
+var defineTool = (config) => ({
+  name: config.name,
+  description: config.description,
+  inputSchema: config.input,
+  execute: config.execute
+});
+
+// src/transport/resolve.ts
+var RESPOND_TOOL_NAME = "respond";
+var FULL_PARAMS_MAX_CHARS = 8192;
+var analyzeWireSchema = (schema) => {
+  try {
+    const serialized = schema["~standard"].jsonSchema.output({ target: "draft-07" });
+    const text = JSON.stringify(serialized);
+    return { serialized, hasRef: text.includes('"$ref"'), size: text.length };
+  } catch {
+    return { serialized: null, hasRef: false, size: Number.POSITIVE_INFINITY };
+  }
+};
+var toJsonSchemaRecord = (schema) => {
+  const convert = schema["~standard"].jsonSchema.output;
+  try {
+    return convert({ target: "draft-07" });
+  } catch {
+    return convert({ target: "draft-07", libraryOptions: { unrepresentable: "any" } });
+  }
+};
+var respondParams = (spec, caps, analysis, fullIsViable) => {
+  if (caps.validatesToolArgs) {
+    return {
+      detail: "permissive",
+      parameters: {
+        type: "object",
+        properties: spec.hasData ? { response: {}, data: {}, reasoning: {} } : { response: {}, reasoning: {} }
+      }
+    };
+  }
+  if (!spec.hasData || fullIsViable) {
+    return { detail: "full", parameters: analysis.serialized ?? toJsonSchemaRecord(spec.wire) };
+  }
+  return { detail: "loose", parameters: toJsonSchemaRecord(spec.looseWire) };
+};
+var protocolSpec = (transport, spec, injectSchemaDoc) => ({
+  transport,
+  responseMode: spec.responseMode,
+  hasData: spec.hasData,
+  hasTools: spec.hasTools,
+  injectSchemaDoc
+});
+var resolveTransport = (spec, caps) => {
+  const analysis = analyzeWireSchema(spec.wire);
+  const fullIsViable = analysis.serialized !== null && !analysis.hasRef && analysis.size <= FULL_PARAMS_MAX_CHARS;
+  const nativeIsViable = caps.nativeJsonSchema && fullIsViable && (!spec.hasTools || caps.toolsWithStructuredOutput);
+  const choice = spec.choice ?? "auto";
+  if (choice === "native" && !nativeIsViable) {
+    throw new SignalError(
+      spec.hasTools && !caps.toolsWithStructuredOutput ? 'transport "native" needs a provider that combines tools with response_format (capabilities.toolsWithStructuredOutput)' : 'transport "native" needs capabilities.nativeJsonSchema and a wire schema that serializes small and non-recursive',
+      ErrorCode.VALIDATION_FAILED
+    );
+  }
+  const respondEnforces = !caps.validatesToolArgs && !caps.manglesNestedToolArgs && (!spec.hasData || fullIsViable);
+  let transport;
+  if (choice !== "auto") transport = choice;
+  else if (nativeIsViable && spec.hasData) transport = "native";
+  else if (respondEnforces || spec.forceTool) transport = "respond";
+  else transport = "emit";
+  if (transport === "emit" && spec.forceTool) {
+    throw new SignalError(
+      "output.forceTool cannot combine with the emit transport \u2014 the final turn must be a content-only message",
+      ErrorCode.VALIDATION_FAILED
+    );
+  }
+  if (transport === "native") {
+    const serialized = analysis.serialized ?? toJsonSchemaRecord(spec.wire);
+    const injectSchemaDoc2 = false;
+    return {
+      transport,
+      responseMode: spec.responseMode,
+      responseFormat: {
+        type: "json_schema",
+        // strict:false — strict mode rejects open records and several
+        // keywords; non-strict still constrains and never hard-fails.
+        jsonSchema: { name: "envelope", strict: false, schema: serialized }
+      },
+      injectSchemaDoc: injectSchemaDoc2,
+      finishProtocol: finishProtocol(protocolSpec(transport, spec, injectSchemaDoc2)),
+      corrections: corrections(transport)
+    };
+  }
+  if (transport === "emit") {
+    const injectSchemaDoc2 = spec.hasData;
+    return {
+      transport,
+      responseMode: spec.responseMode,
+      injectSchemaDoc: injectSchemaDoc2,
+      finishProtocol: finishProtocol(protocolSpec(transport, spec, injectSchemaDoc2)),
+      corrections: corrections(transport)
+    };
+  }
+  const { detail: respondDetail, parameters } = respondParams(spec, caps, analysis, fullIsViable);
+  const injectSchemaDoc = spec.hasData && respondDetail !== "full";
+  return {
+    transport,
+    responseMode: spec.responseMode,
+    respondDetail,
+    respondDescriptor: { name: RESPOND_TOOL_NAME, description: RESPOND_DESCRIPTION, parameters },
+    outputToolName: RESPOND_TOOL_NAME,
+    ...spec.forceTool && { toolChoice: "required" },
+    injectSchemaDoc,
+    finishProtocol: finishProtocol(protocolSpec(transport, spec, injectSchemaDoc)),
+    corrections: corrections(transport)
+  };
+};
+
+// src/types.ts
+var REASONING_EFFORTS = ["none", "default", "minimal", "low", "medium", "high", "xhigh", "max"];
+
+exports.ErrorCode = ErrorCode;
+exports.REASONING_EFFORTS = REASONING_EFFORTS;
+exports.RESPOND_TOOL_NAME = RESPOND_TOOL_NAME;
+exports.SignalError = SignalError;
+exports.UNMEASURED_MODEL = UNMEASURED_MODEL;
+exports.chatProviderEntry = chatProviderEntry;
+exports.closeTruncated = closeTruncated;
+exports.createSignal = createSignal;
+exports.decodeJsonish = decodeJsonish;
+exports.deepDecodeJsonish = deepDecodeJsonish;
+exports.defineTool = defineTool;
+exports.extractJson = extractJson;
+exports.isTruncatedJson = isTruncatedJson;
+exports.modelEntry = modelEntry;
+exports.modelKey = modelKey;
+exports.modelRegistry = modelRegistry;
+exports.providerRegistry = providerRegistry;
+exports.repairEscapeDamage = repairEscapeDamage;
+exports.resolveTransport = resolveTransport;
+exports.routeRejection = routeRejection;
+exports.routeResponse = routeResponse;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map