@skaile/workspaces 5.12.0 → 5.14.0

package/dist/chunk-OKQXY6FS.js

@@ -0,0 +1,1336 @@
+import { selectableEntries, entryModelIds, entrySurface, entryBaseUrl } from './chunk-IQVZIVSA.js';
+import { entryCredentialValue } from './chunk-6VIVUBNN.js';
+import { parseModelRef } from './chunk-MJHSLODD.js';
+import { createHash, timingSafeEqual, randomUUID } from 'crypto';
+import { createServer } from 'http';
+
+// model-endpoint/src/types.ts
+var ModelEndpointError = class extends Error {
+  status;
+  type;
+  code;
+  constructor(status, message, code, type) {
+    super(message);
+    this.name = "ModelEndpointError";
+    this.status = status;
+    this.type = type ?? defaultErrorType(status);
+    if (code !== void 0) this.code = code;
+  }
+};
+function defaultErrorType(status) {
+  if (status === 401 || status === 403) return "authentication_error";
+  if (status === 404) return "not_found_error";
+  if (status === 502 || status === 503 || status === 504) return "upstream_error";
+  if (status >= 500 && status !== 501) return "server_error";
+  return "invalid_request_error";
+}
+
+// model-endpoint/src/resolve.ts
+var DEFAULT_CONTEXT_WINDOW = 128e3;
+var DEFAULT_MAX_TOKENS = 8192;
+var KEYLESS_PLACEHOLDER = "unused";
+function piBaseUrl(_surface, registryBaseUrl) {
+  return registryBaseUrl.replace(/\/+$/, "");
+}
+function resolveModel(selector, deps) {
+  const ref = parseModelRef(selector, deps.registry, deps.roles);
+  if (!ref || ref.modelId === void 0) {
+    throw new ModelEndpointError(404, `model '${selector}' not found`, "model_not_found");
+  }
+  const found = selectableEntries(deps.registry).find(([id]) => id === ref.providerId);
+  if (!found) {
+    throw new ModelEndpointError(404, `model '${selector}' not found`, "model_not_found");
+  }
+  const [providerId, entry] = found;
+  const logicalId = ref.modelId;
+  const declared = entryModelIds(entry);
+  if (declared.length > 0 && !declared.some(([id]) => id === logicalId)) {
+    throw new ModelEndpointError(
+      404,
+      `model '${logicalId}' is not declared by provider '${providerId}'`,
+      "model_not_found"
+    );
+  }
+  const surface = entrySurface(entry);
+  const baseUrl = entryBaseUrl(entry);
+  if (!surface || !baseUrl) {
+    throw new ModelEndpointError(
+      502,
+      `provider '${providerId}' is incomplete: it needs a surface and a base_url`,
+      "provider_incomplete"
+    );
+  }
+  const providerModelId = ref.providerModelId ?? logicalId;
+  const caps = entry.capabilities?.[logicalId];
+  const model = {
+    id: providerModelId,
+    name: logicalId,
+    api: surface,
+    provider: providerId,
+    baseUrl: piBaseUrl(surface, baseUrl),
+    input: caps?.images === false ? ["text"] : ["text", "image"],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    reasoning: true,
+    contextWindow: caps?.context_window ?? DEFAULT_CONTEXT_WINDOW,
+    maxTokens: DEFAULT_MAX_TOKENS,
+    ...entry.headers ? { headers: entry.headers } : {}
+  };
+  const apiKey = entryCredentialValue(providerId, entry, { env: deps.lookupEnv, allowCommand: false }) ?? (isKeyless(entry) ? KEYLESS_PLACEHOLDER : void 0);
+  return {
+    providerId,
+    logicalId,
+    model,
+    ...apiKey !== void 0 ? { apiKey } : {},
+    ...entry.headers ? { headers: entry.headers } : {}
+  };
+}
+function isKeyless(entry) {
+  return !entry.preset && (!entry.credential || entry.credential.kind === "none");
+}
+function listModels(registry) {
+  return selectableEntries(registry).flatMap(
+    ([providerId, entry]) => entryModelIds(entry).map(([logicalId]) => ({
+      id: `${providerId}/${logicalId}`,
+      owned_by: providerId
+    }))
+  );
+}
+
+// model-endpoint/src/openai-shared.ts
+var THINKING_LEVELS = [
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max"
+];
+function badRequest(message) {
+  return new ModelEndpointError(400, message);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireModel(body) {
+  if (typeof body.model !== "string" || body.model.length === 0) {
+    throw badRequest("model is required");
+  }
+  return body.model;
+}
+function optionalBoolean(value, field) {
+  if (value === void 0 || value === null) return false;
+  if (typeof value !== "boolean") throw badRequest(`${field} must be a boolean`);
+  return value;
+}
+function optionalNumber(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw badRequest(`${field} must be a number`);
+  return value;
+}
+function optionalPositiveInt(value, field) {
+  const n = optionalNumber(value, field);
+  if (n === void 0) return void 0;
+  if (!Number.isInteger(n) || n <= 0) throw badRequest(`${field} must be a positive integer`);
+  return n;
+}
+function isThinkingLevel(value) {
+  return THINKING_LEVELS.includes(value);
+}
+function parseReasoningEffort(value, field) {
+  if (value === void 0 || value === null || value === "none") return void 0;
+  if (typeof value === "string" && isThinkingLevel(value)) return value;
+  throw badRequest(`${field} must be one of none, ${THINKING_LEVELS.join(", ")}`);
+}
+function pickSamplingParams(body, keys) {
+  const picked = {};
+  for (const key of keys) {
+    const value = body[key];
+    if (value === void 0 || value === null) continue;
+    const ok = typeof value === "string" || typeof value === "number" && Number.isFinite(value) || Array.isArray(value) && value.every((v) => typeof v === "string");
+    if (!ok) throw badRequest(`${key} has an unsupported type`);
+    picked[key] = value;
+  }
+  return Object.keys(picked).length > 0 ? picked : void 0;
+}
+function buildOptions(parts) {
+  const options = {};
+  if (parts.temperature !== void 0) options.temperature = parts.temperature;
+  if (parts.maxTokens !== void 0) options.maxTokens = parts.maxTokens;
+  if (parts.samplingParams !== void 0) options.samplingParams = parts.samplingParams;
+  if (parts.reasoning !== void 0) options.reasoning = parts.reasoning;
+  return options;
+}
+var DATA_URL = /^data:([^;,]+)(?:;[^;,]*)*;base64,(.*)$/s;
+function imageFromUrl(url, field) {
+  if (typeof url !== "string" || url.length === 0)
+    throw badRequest(`${field} must be a non-empty string`);
+  const match = DATA_URL.exec(url);
+  if (!match) {
+    throw badRequest(
+      `${field}: only base64 data: image URLs are supported; http(s) image URLs are not fetched`
+    );
+  }
+  const mimeType = match[1];
+  if (!mimeType.startsWith("image/"))
+    throw badRequest(`${field}: data URL is not an image (${mimeType})`);
+  return { type: "image", data: match[2], mimeType };
+}
+function parseToolArguments(value) {
+  if (isRecord(value)) return value;
+  if (typeof value !== "string" || value.trim().length === 0) return {};
+  try {
+    const parsed = JSON.parse(value);
+    return isRecord(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+var DEFAULT_TOOL_PARAMETERS = { type: "object", properties: {} };
+function toPiTool(name, description, parameters) {
+  return {
+    name,
+    description: typeof description === "string" ? description : "",
+    parameters: isRecord(parameters) ? parameters : DEFAULT_TOOL_PARAMETERS
+  };
+}
+function selectTools(tools, choice, forcedName) {
+  if (choice === void 0 || choice === null || choice === "auto" || choice === "required")
+    return tools;
+  if (choice === "none") return [];
+  if (isRecord(choice)) {
+    const name = forcedName(choice);
+    const matched = tools.filter((tool) => tool.name === name);
+    if (typeof name !== "string" || matched.length === 0) {
+      throw badRequest("tool_choice references an unknown function");
+    }
+    return matched;
+  }
+  throw badRequest("tool_choice is not supported");
+}
+function buildContext(systemParts, messages, tools) {
+  const context = { messages };
+  if (systemParts.length > 0) context.systemPrompt = systemParts.join("\n\n");
+  if (tools.length > 0) context.tools = tools;
+  return context;
+}
+function emptyUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+}
+function promptTokens(usage) {
+  return usage.input + usage.cacheRead + usage.cacheWrite;
+}
+function totalTokens(usage) {
+  return usage.totalTokens > 0 ? usage.totalTokens : promptTokens(usage) + usage.output;
+}
+function historyAssistant(model, content) {
+  return {
+    role: "assistant",
+    content,
+    api: "openai-completions",
+    provider: "openai",
+    model,
+    usage: emptyUsage(),
+    stopReason: content.some((block) => block.type === "toolCall") ? "toolUse" : "stop",
+    timestamp: Date.now()
+  };
+}
+function historyToolResult(toolCallId, toolName, text) {
+  return {
+    role: "toolResult",
+    toolCallId,
+    toolName,
+    content: [{ type: "text", text }],
+    isError: false,
+    timestamp: Date.now()
+  };
+}
+
+// model-endpoint/src/openai-chat.ts
+function textOfParts(content, field, allowed) {
+  if (content === void 0 || content === null) return "";
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content))
+    throw badRequest(`${field} must be a string or an array of text parts`);
+  let text = "";
+  for (let i = 0; i < content.length; i++) {
+    const part = content[i];
+    if (!isRecord(part) || typeof part.type !== "string" || !allowed.includes(part.type)) {
+      throw badRequest(`${field}[${i}]: unsupported content part`);
+    }
+    const value = part.type === "refusal" ? part.refusal : part.text;
+    if (typeof value !== "string")
+      throw badRequest(
+        `${field}[${i}].${part.type === "refusal" ? "refusal" : "text"} must be a string`
+      );
+    text += value;
+  }
+  return text;
+}
+function parseUserContent(content, field) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content))
+    throw badRequest(`${field} must be a string or an array of content parts`);
+  const parts = [];
+  for (let i = 0; i < content.length; i++) {
+    const part = content[i];
+    const partField = `${field}[${i}]`;
+    if (!isRecord(part)) throw badRequest(`${partField} must be an object`);
+    if (part.type === "text") {
+      if (typeof part.text !== "string") throw badRequest(`${partField}.text must be a string`);
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "image_url") {
+      const url = isRecord(part.image_url) ? part.image_url.url : part.image_url;
+      parts.push(imageFromUrl(url, `${partField}.image_url.url`));
+    } else {
+      throw badRequest(`${partField}: unsupported content part type "${String(part.type)}"`);
+    }
+  }
+  return parts;
+}
+function parseAssistantMessage(raw, field, model, toolNames) {
+  const blocks = [];
+  const text = textOfParts(raw.content, `${field}.content`, ["text", "refusal"]);
+  if (text.length > 0) blocks.push({ type: "text", text });
+  if (raw.tool_calls !== void 0 && raw.tool_calls !== null) {
+    if (!Array.isArray(raw.tool_calls)) throw badRequest(`${field}.tool_calls must be an array`);
+    for (let i = 0; i < raw.tool_calls.length; i++) {
+      const call = raw.tool_calls[i];
+      const callField = `${field}.tool_calls[${i}]`;
+      if (!isRecord(call) || !isRecord(call.function))
+        throw badRequest(`${callField} must be a function tool call`);
+      if (call.type !== void 0 && call.type !== "function")
+        throw badRequest(`${callField}.type must be "function"`);
+      if (typeof call.id !== "string" || call.id.length === 0)
+        throw badRequest(`${callField}.id is required`);
+      if (typeof call.function.name !== "string" || call.function.name.length === 0) {
+        throw badRequest(`${callField}.function.name is required`);
+      }
+      toolNames.set(call.id, call.function.name);
+      blocks.push({
+        type: "toolCall",
+        id: call.id,
+        name: call.function.name,
+        arguments: parseToolArguments(call.function.arguments)
+      });
+    }
+  }
+  return blocks.length > 0 ? historyAssistant(model, blocks) : void 0;
+}
+function parseTools(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) throw badRequest("tools must be an array");
+  const tools = [];
+  for (let i = 0; i < value.length; i++) {
+    const tool = value[i];
+    if (!isRecord(tool) || tool.type !== "function" || !isRecord(tool.function)) {
+      throw badRequest(`tools[${i}] must be {type:"function", function:{...}}`);
+    }
+    const fn = tool.function;
+    if (typeof fn.name !== "string" || fn.name.length === 0)
+      throw badRequest(`tools[${i}].function.name is required`);
+    tools.push(toPiTool(fn.name, fn.description, fn.parameters));
+  }
+  return tools;
+}
+function parseChatCompletionRequest(body) {
+  if (!isRecord(body)) throw badRequest("request body must be a JSON object");
+  const model = requireModel(body);
+  if (!Array.isArray(body.messages) || body.messages.length === 0) {
+    throw badRequest("messages must be a non-empty array");
+  }
+  if (body.n !== void 0 && body.n !== null && body.n !== 1) {
+    throw badRequest("n must be 1; multiple choices are not supported");
+  }
+  const systemParts = [];
+  const messages = [];
+  const toolNames = /* @__PURE__ */ new Map();
+  for (let i = 0; i < body.messages.length; i++) {
+    const raw = body.messages[i];
+    const field = `messages[${i}]`;
+    if (!isRecord(raw)) throw badRequest(`${field} must be an object`);
+    switch (raw.role) {
+      case "system":
+      case "developer": {
+        const text = textOfParts(raw.content, `${field}.content`, ["text"]);
+        if (text.length > 0) systemParts.push(text);
+        break;
+      }
+      case "user":
+        messages.push({
+          role: "user",
+          content: parseUserContent(raw.content, `${field}.content`),
+          timestamp: Date.now()
+        });
+        break;
+      case "assistant": {
+        const assistant = parseAssistantMessage(raw, field, model, toolNames);
+        if (assistant) messages.push(assistant);
+        break;
+      }
+      case "tool": {
+        if (typeof raw.tool_call_id !== "string" || raw.tool_call_id.length === 0) {
+          throw badRequest(`${field}.tool_call_id is required`);
+        }
+        const text = textOfParts(raw.content, `${field}.content`, ["text"]);
+        messages.push(
+          historyToolResult(raw.tool_call_id, toolNames.get(raw.tool_call_id) ?? "", text)
+        );
+        break;
+      }
+      default:
+        throw badRequest(`${field}.role "${String(raw.role)}" is not supported`);
+    }
+  }
+  const tools = selectTools(
+    parseTools(body.tools),
+    body.tool_choice,
+    (choice) => choice.type === "function" && isRecord(choice.function) ? choice.function.name : void 0
+  );
+  const options = buildOptions({
+    temperature: optionalNumber(body.temperature, "temperature"),
+    maxTokens: optionalPositiveInt(
+      body.max_completion_tokens ?? body.max_tokens,
+      "max_completion_tokens"
+    ),
+    samplingParams: pickSamplingParams(body, [
+      "top_p",
+      "frequency_penalty",
+      "presence_penalty",
+      "seed",
+      "stop"
+    ]),
+    reasoning: parseReasoningEffort(body.reasoning_effort, "reasoning_effort")
+  });
+  return {
+    model,
+    context: buildContext(systemParts, messages, tools),
+    options,
+    stream: optionalBoolean(body.stream, "stream"),
+    includeUsage: isRecord(body.stream_options) && body.stream_options.include_usage === true
+  };
+}
+function finishReason(stopReason, errorMessage) {
+  switch (stopReason) {
+    case "length":
+      return "length";
+    case "toolUse":
+      return "tool_calls";
+    case "error":
+    case "aborted":
+      throw new ModelEndpointError(502, errorMessage ?? `upstream request ${stopReason}`);
+    default:
+      return "stop";
+  }
+}
+function toChatUsage(usage) {
+  const prompt = promptTokens(usage);
+  const result = {
+    prompt_tokens: prompt,
+    completion_tokens: usage.output,
+    total_tokens: totalTokens(usage),
+    prompt_tokens_details: { cached_tokens: usage.cacheRead }
+  };
+  if (usage.reasoning !== void 0)
+    result.completion_tokens_details = { reasoning_tokens: usage.reasoning };
+  return result;
+}
+function toChatCompletion(message, meta) {
+  const reason = finishReason(message.stopReason, message.errorMessage);
+  let text = "";
+  let thinking = "";
+  const toolCalls = [];
+  for (const block of message.content) {
+    if (block.type === "text") text += block.text;
+    else if (block.type === "thinking") thinking += block.thinking;
+    else {
+      toolCalls.push({
+        id: block.id,
+        type: "function",
+        function: { name: block.name, arguments: JSON.stringify(block.arguments) }
+      });
+    }
+  }
+  const out = { role: "assistant", content: text.length > 0 ? text : null };
+  if (thinking.length > 0) out.reasoning_content = thinking;
+  if (toolCalls.length > 0) out.tool_calls = toolCalls;
+  return {
+    id: meta.id,
+    object: "chat.completion",
+    created: meta.created,
+    model: meta.model,
+    choices: [{ index: 0, message: out, finish_reason: reason }],
+    usage: toChatUsage(message.usage)
+  };
+}
+function createChatStreamState(init) {
+  return { ...init, nextToolIndex: 0, toolIndexByContent: /* @__PURE__ */ new Map() };
+}
+function chunk(state, delta, finish = null) {
+  return {
+    id: state.id,
+    object: "chat.completion.chunk",
+    created: state.created,
+    model: state.model,
+    choices: [{ index: 0, delta, finish_reason: finish }]
+  };
+}
+function chatCompletionChunks(event, state) {
+  switch (event.type) {
+    case "start":
+      return [chunk(state, { role: "assistant", content: "" })];
+    case "text_delta":
+      return event.delta.length > 0 ? [chunk(state, { content: event.delta })] : [];
+    case "thinking_delta":
+      return event.delta.length > 0 ? [chunk(state, { reasoning_content: event.delta })] : [];
+    case "toolcall_start":
+      state.toolIndexByContent.set(event.contentIndex, state.nextToolIndex++);
+      return [];
+    case "toolcall_end": {
+      let index = state.toolIndexByContent.get(event.contentIndex);
+      if (index === void 0) {
+        index = state.nextToolIndex++;
+        state.toolIndexByContent.set(event.contentIndex, index);
+      }
+      return [
+        chunk(state, {
+          tool_calls: [
+            {
+              index,
+              id: event.toolCall.id,
+              type: "function",
+              function: {
+                name: event.toolCall.name,
+                arguments: JSON.stringify(event.toolCall.arguments)
+              }
+            }
+          ]
+        })
+      ];
+    }
+    case "done": {
+      const chunks = [chunk(state, {}, finishReason(event.reason, void 0))];
+      if (state.includeUsage) {
+        chunks.push({
+          id: state.id,
+          object: "chat.completion.chunk",
+          created: state.created,
+          model: state.model,
+          choices: [],
+          usage: toChatUsage(event.message.usage)
+        });
+      }
+      return chunks;
+    }
+    case "error":
+      state.error = event.error.errorMessage ?? `upstream request ${event.reason}`;
+      return [];
+    default:
+      return [];
+  }
+}
+
+// model-endpoint/src/openai-responses.ts
+function parseParts(content, field, role) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content))
+    throw badRequest(`${field} must be a string or an array of content parts`);
+  const textTypes = role === "assistant" ? ["output_text", "text"] : ["input_text", "text"];
+  const parts = [];
+  for (let i = 0; i < content.length; i++) {
+    const part = content[i];
+    const partField = `${field}[${i}]`;
+    if (!isRecord(part) || typeof part.type !== "string")
+      throw badRequest(`${partField} must be a content part`);
+    if (textTypes.includes(part.type)) {
+      if (typeof part.text !== "string") throw badRequest(`${partField}.text must be a string`);
+      parts.push({ type: "text", text: part.text });
+    } else if (part.type === "refusal" && role === "assistant" && typeof part.refusal === "string") {
+      parts.push({ type: "text", text: part.refusal });
+    } else if (part.type === "input_image" && role === "user") {
+      if (part.file_id !== void 0 && part.file_id !== null)
+        throw badRequest(`${partField}.file_id is not supported`);
+      const url = isRecord(part.image_url) ? part.image_url.url : part.image_url;
+      parts.push(imageFromUrl(url, `${partField}.image_url`));
+    } else {
+      throw badRequest(`${partField}: unsupported content part type "${part.type}"`);
+    }
+  }
+  return parts;
+}
+function joinText(parts) {
+  if (typeof parts === "string") return parts;
+  return parts.map((part) => part.type === "text" ? part.text : "").join("");
+}
+function parseOutputText(output, field) {
+  if (typeof output === "string") return output;
+  if (output === void 0 || output === null) return "";
+  return joinText(parseParts(output, field, "user"));
+}
+function parseInput(input, model, systemParts) {
+  if (typeof input === "string") return [{ role: "user", content: input, timestamp: Date.now() }];
+  if (!Array.isArray(input)) throw badRequest("input must be a string or an array of items");
+  const messages = [];
+  const toolNames = /* @__PURE__ */ new Map();
+  for (let i = 0; i < input.length; i++) {
+    const item = input[i];
+    const field = `input[${i}]`;
+    if (!isRecord(item)) throw badRequest(`${field} must be an object`);
+    const type = item.type ?? "message";
+    switch (type) {
+      case "message": {
+        const role = item.role;
+        if (role === "system" || role === "developer") {
+          const text = joinText(parseParts(item.content, `${field}.content`, "system"));
+          if (text.length > 0) systemParts.push(text);
+        } else if (role === "user") {
+          messages.push({
+            role: "user",
+            content: parseParts(item.content, `${field}.content`, "user"),
+            timestamp: Date.now()
+          });
+        } else if (role === "assistant") {
+          const text = joinText(parseParts(item.content, `${field}.content`, "assistant"));
+          if (text.length > 0) messages.push(historyAssistant(model, [{ type: "text", text }]));
+        } else {
+          throw badRequest(`${field}.role "${String(role)}" is not supported`);
+        }
+        break;
+      }
+      case "function_call": {
+        if (typeof item.call_id !== "string" || item.call_id.length === 0)
+          throw badRequest(`${field}.call_id is required`);
+        if (typeof item.name !== "string" || item.name.length === 0)
+          throw badRequest(`${field}.name is required`);
+        toolNames.set(item.call_id, item.name);
+        const call = {
+          type: "toolCall",
+          id: item.call_id,
+          name: item.name,
+          arguments: parseToolArguments(item.arguments)
+        };
+        const last = messages.at(-1);
+        if (last?.role === "assistant") {
+          last.content.push(call);
+          last.stopReason = "toolUse";
+        } else {
+          messages.push(historyAssistant(model, [call]));
+        }
+        break;
+      }
+      case "function_call_output": {
+        if (typeof item.call_id !== "string" || item.call_id.length === 0)
+          throw badRequest(`${field}.call_id is required`);
+        messages.push(
+          historyToolResult(
+            item.call_id,
+            toolNames.get(item.call_id) ?? "",
+            parseOutputText(item.output, `${field}.output`)
+          )
+        );
+        break;
+      }
+      case "reasoning":
+        break;
+      default:
+        throw badRequest(`${field}.type "${String(type)}" is not supported`);
+    }
+  }
+  return messages;
+}
+function parseTools2(value) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) throw badRequest("tools must be an array");
+  const tools = [];
+  for (let i = 0; i < value.length; i++) {
+    const tool = value[i];
+    if (!isRecord(tool) || tool.type !== "function") {
+      throw badRequest(`tools[${i}]: only function tools are supported`);
+    }
+    if (typeof tool.name !== "string" || tool.name.length === 0)
+      throw badRequest(`tools[${i}].name is required`);
+    tools.push(toPiTool(tool.name, tool.description, tool.parameters));
+  }
+  return tools;
+}
+function parseResponsesRequest(body) {
+  if (!isRecord(body)) throw badRequest("request body must be a JSON object");
+  const model = requireModel(body);
+  if (body.input === void 0 || body.input === null) throw badRequest("input is required");
+  if (body.previous_response_id !== void 0 && body.previous_response_id !== null) {
+    throw badRequest("previous_response_id is not supported; the endpoint is stateless");
+  }
+  const systemParts = [];
+  if (body.instructions !== void 0 && body.instructions !== null) {
+    if (typeof body.instructions !== "string") throw badRequest("instructions must be a string");
+    if (body.instructions.length > 0) systemParts.push(body.instructions);
+  }
+  const messages = parseInput(body.input, model, systemParts);
+  if (messages.length === 0) throw badRequest("input must contain at least one message");
+  const tools = selectTools(
+    parseTools2(body.tools),
+    body.tool_choice,
+    (choice) => choice.type === "function" ? choice.name : void 0
+  );
+  const reasoning = isRecord(body.reasoning) ? body.reasoning.effort : void 0;
+  const options = buildOptions({
+    temperature: optionalNumber(body.temperature, "temperature"),
+    maxTokens: optionalPositiveInt(body.max_output_tokens, "max_output_tokens"),
+    samplingParams: pickSamplingParams(body, ["top_p"]),
+    reasoning: parseReasoningEffort(reasoning, "reasoning.effort")
+  });
+  return {
+    model,
+    context: buildContext(systemParts, messages, tools),
+    options,
+    stream: optionalBoolean(body.stream, "stream"),
+    includeUsage: true
+  };
+}
+function itemId(prefix, responseId, index) {
+  return `${prefix}_${responseId.replace(/^resp_/, "")}_${index}`;
+}
+function toResponseUsage(usage) {
+  return {
+    input_tokens: promptTokens(usage),
+    output_tokens: usage.output,
+    total_tokens: totalTokens(usage),
+    input_tokens_details: { cached_tokens: usage.cacheRead },
+    output_tokens_details: { reasoning_tokens: usage.reasoning ?? 0 }
+  };
+}
+function messageItem(id, text, status) {
+  return {
+    type: "message",
+    id,
+    role: "assistant",
+    status,
+    content: status === "completed" ? [{ type: "output_text", text, annotations: [] }] : []
+  };
+}
+function buildOutput(message, responseId) {
+  const output = [];
+  const summaries = [];
+  let text = "";
+  const calls = [];
+  for (const block of message.content) {
+    if (block.type === "thinking") {
+      if (block.thinking.length > 0) summaries.push({ type: "summary_text", text: block.thinking });
+    } else if (block.type === "text") {
+      text += block.text;
+    } else {
+      calls.push({
+        type: "function_call",
+        id: "",
+        call_id: block.id,
+        name: block.name,
+        arguments: JSON.stringify(block.arguments),
+        status: "completed"
+      });
+    }
+  }
+  if (summaries.length > 0) {
+    output.push({
+      type: "reasoning",
+      id: itemId("rs", responseId, output.length),
+      summary: summaries
+    });
+  }
+  if (text.length > 0) {
+    output.push(messageItem(itemId("msg", responseId, output.length), text, "completed"));
+  }
+  for (const call of calls) {
+    call.id = itemId("fc", responseId, output.length);
+    output.push(call);
+  }
+  return output;
+}
+function responseObject(meta, status, output, usage) {
+  return {
+    id: meta.id,
+    object: "response",
+    created_at: meta.created,
+    model: meta.model,
+    status,
+    incomplete_details: status === "incomplete" ? { reason: "max_output_tokens" } : null,
+    error: null,
+    output,
+    usage: usage ? toResponseUsage(usage) : null
+  };
+}
+function toResponse(message, meta) {
+  if (message.stopReason === "error" || message.stopReason === "aborted") {
+    throw new ModelEndpointError(
+      502,
+      message.errorMessage ?? `upstream request ${message.stopReason}`
+    );
+  }
+  const status = message.stopReason === "length" ? "incomplete" : "completed";
+  return responseObject(meta, status, buildOutput(message, meta.id), message.usage);
+}
+function createResponsesStreamState(init) {
+  return {
+    ...init,
+    sequence: 0,
+    nextOutputIndex: 0,
+    open: /* @__PURE__ */ new Map(),
+    completed: /* @__PURE__ */ new Map()
+  };
+}
+function ev(state, type, fields) {
+  return { type, sequence_number: state.sequence++, ...fields };
+}
+function openBlock(state, contentIndex, kind) {
+  const existing = state.open.get(contentIndex);
+  if (existing) return { block: existing, events: [] };
+  const outputIndex = state.nextOutputIndex++;
+  const block = {
+    kind,
+    outputIndex,
+    itemId: itemId(kind === "message" ? "msg" : "rs", state.id, outputIndex),
+    text: ""
+  };
+  state.open.set(contentIndex, block);
+  if (kind === "message") {
+    return {
+      block,
+      events: [
+        ev(state, "response.output_item.added", {
+          output_index: outputIndex,
+          item: messageItem(block.itemId, "", "in_progress")
+        }),
+        ev(state, "response.content_part.added", {
+          item_id: block.itemId,
+          output_index: outputIndex,
+          content_index: 0,
+          part: { type: "output_text", text: "", annotations: [] }
+        })
+      ]
+    };
+  }
+  return {
+    block,
+    events: [
+      ev(state, "response.output_item.added", {
+        output_index: outputIndex,
+        item: { type: "reasoning", id: block.itemId, summary: [] }
+      }),
+      ev(state, "response.reasoning_summary_part.added", {
+        item_id: block.itemId,
+        output_index: outputIndex,
+        summary_index: 0,
+        part: { type: "summary_text", text: "" }
+      })
+    ]
+  };
+}
+function closeBlock(state, contentIndex, kind, finalText) {
+  const { block, events } = openBlock(state, contentIndex, kind);
+  state.open.delete(contentIndex);
+  if (kind === "message") {
+    const item2 = messageItem(block.itemId, finalText, "completed");
+    state.completed.set(block.outputIndex, item2);
+    events.push(
+      ev(state, "response.output_text.done", {
+        item_id: block.itemId,
+        output_index: block.outputIndex,
+        content_index: 0,
+        text: finalText
+      }),
+      ev(state, "response.content_part.done", {
+        item_id: block.itemId,
+        output_index: block.outputIndex,
+        content_index: 0,
+        part: { type: "output_text", text: finalText, annotations: [] }
+      }),
+      ev(state, "response.output_item.done", { output_index: block.outputIndex, item: item2 })
+    );
+    return events;
+  }
+  const part = { type: "summary_text", text: finalText };
+  const item = { type: "reasoning", id: block.itemId, summary: [part] };
+  state.completed.set(block.outputIndex, item);
+  events.push(
+    ev(state, "response.reasoning_summary_text.done", {
+      item_id: block.itemId,
+      output_index: block.outputIndex,
+      summary_index: 0,
+      text: finalText
+    }),
+    ev(state, "response.reasoning_summary_part.done", {
+      item_id: block.itemId,
+      output_index: block.outputIndex,
+      summary_index: 0,
+      part
+    }),
+    ev(state, "response.output_item.done", { output_index: block.outputIndex, item })
+  );
+  return events;
+}
+function responsesEvents(event, state) {
+  const meta = { id: state.id, created: state.created, model: state.model };
+  switch (event.type) {
+    case "start": {
+      const response = responseObject(meta, "in_progress", [], void 0);
+      return [
+        ev(state, "response.created", { response }),
+        ev(state, "response.in_progress", { response })
+      ];
+    }
+    case "text_start":
+      return openBlock(state, event.contentIndex, "message").events;
+    case "text_delta": {
+      const { block, events } = openBlock(state, event.contentIndex, "message");
+      block.text += event.delta;
+      events.push(
+        ev(state, "response.output_text.delta", {
+          item_id: block.itemId,
+          output_index: block.outputIndex,
+          content_index: 0,
+          delta: event.delta
+        })
+      );
+      return events;
+    }
+    case "text_end":
+      return closeBlock(state, event.contentIndex, "message", event.content);
+    case "thinking_start":
+      return openBlock(state, event.contentIndex, "reasoning").events;
+    case "thinking_delta": {
+      const { block, events } = openBlock(state, event.contentIndex, "reasoning");
+      block.text += event.delta;
+      events.push(
+        ev(state, "response.reasoning_summary_text.delta", {
+          item_id: block.itemId,
+          output_index: block.outputIndex,
+          summary_index: 0,
+          delta: event.delta
+        })
+      );
+      return events;
+    }
+    case "thinking_end":
+      return closeBlock(state, event.contentIndex, "reasoning", event.content);
+    case "toolcall_end": {
+      const outputIndex = state.nextOutputIndex++;
+      const id = itemId("fc", state.id, outputIndex);
+      const args = JSON.stringify(event.toolCall.arguments);
+      const item = {
+        type: "function_call",
+        id,
+        call_id: event.toolCall.id,
+        name: event.toolCall.name,
+        arguments: args,
+        status: "completed"
+      };
+      state.completed.set(outputIndex, item);
+      return [
+        ev(state, "response.output_item.added", {
+          output_index: outputIndex,
+          item: { ...item, arguments: "", status: "in_progress" }
+        }),
+        ev(state, "response.function_call_arguments.delta", {
+          item_id: id,
+          output_index: outputIndex,
+          delta: args
+        }),
+        ev(state, "response.function_call_arguments.done", {
+          item_id: id,
+          output_index: outputIndex,
+          name: item.name,
+          arguments: args
+        }),
+        ev(state, "response.output_item.done", { output_index: outputIndex, item })
+      ];
+    }
+    case "done": {
+      const streamed = [...state.completed.entries()].sort(([a], [b]) => a - b).map(([, item]) => item);
+      const output = streamed.length > 0 ? streamed : buildOutput(event.message, state.id);
+      const incomplete = event.reason === "length";
+      const response = responseObject(
+        meta,
+        incomplete ? "incomplete" : "completed",
+        output,
+        event.message.usage
+      );
+      return [ev(state, incomplete ? "response.incomplete" : "response.completed", { response })];
+    }
+    case "error":
+      state.error = event.error.errorMessage ?? `upstream request ${event.reason}`;
+      return [];
+    default:
+      return [];
+  }
+}
+
+// model-endpoint/src/server.ts
+var MAX_BODY_BYTES = 10 * 1024 * 1024;
+var EMBEDDING_SURFACES = /* @__PURE__ */ new Set(["openai-completions", "openai-responses"]);
+async function startModelEndpoint(options) {
+  if (!options.token) throw new Error("model endpoint requires a non-empty token");
+  const host = options.host ?? "127.0.0.1";
+  const log = options.log ?? (() => {
+  });
+  const loadApi = options.loadApi ?? defaultLoadApi;
+  const tokenDigest = digest(options.token);
+  const deps = () => ({
+    registry: options.getRegistry(),
+    lookupEnv: options.getLookupEnv(),
+    roles: options.getRoles?.()
+  });
+  function authenticate(req) {
+    const match = /^Bearer\s+(.+)$/i.exec(req.headers.authorization ?? "");
+    if (!match || !timingSafeEqual(digest(match[1] ?? ""), tokenDigest)) {
+      throw new ModelEndpointError(401, "invalid or missing bearer token", "invalid_api_key");
+    }
+  }
+  async function startUpstream(request, resolved, signal) {
+    const pi = await loadPi();
+    const surface = resolved.model.api;
+    let api;
+    try {
+      api = await loadApi(surface);
+    } catch (cause) {
+      throw new ModelEndpointError(
+        501,
+        `surface '${surface}' is not supported by the installed pi-ai: ${errorText(cause)}`,
+        "surface_unsupported"
+      );
+    }
+    const { temperature, maxTokens, samplingParams, reasoning } = request.options;
+    const common = {
+      ...resolved.apiKey !== void 0 ? { apiKey: resolved.apiKey } : {},
+      ...resolved.headers ? { headers: resolved.headers } : {},
+      signal,
+      ...temperature !== void 0 ? { temperature } : {},
+      ...maxTokens !== void 0 ? { maxTokens } : {},
+      ...samplingParams !== void 0 ? { samplingParams } : {}
+    };
+    const context = pi.normalizeContext(request.context);
+    if (reasoning !== void 0 && api.streamSimple) {
+      return api.streamSimple(resolved.model, context, { ...common, reasoning });
+    }
+    return api.stream(resolved.model, context, common);
+  }
+  async function handleChat(req, res, signal, trace) {
+    const request = parseChatCompletionRequest(await readJson(req));
+    const resolved = resolveModel(request.model, deps());
+    trace.target = `${resolved.providerId}/${resolved.logicalId}`;
+    const events = await startUpstream(request, resolved, signal);
+    const id = `chatcmpl-${randomUUID().replaceAll("-", "")}`;
+    const created = Math.floor(Date.now() / 1e3);
+    if (!request.stream) {
+      const message = await collectFinal(events);
+      sendJson(res, 200, toChatCompletion(message, { id, created, model: request.model }));
+      return;
+    }
+    const state = createChatStreamState({
+      id,
+      created,
+      model: request.model,
+      includeUsage: request.includeUsage
+    });
+    await pipeSse(res, events, {
+      frames: (event) => chatCompletionChunks(event, state),
+      errorFrame: (message) => ({ error: { message, type: "upstream_error" } }),
+      terminator: "[DONE]"
+    });
+  }
+  async function handleResponses(req, res, signal, trace) {
+    const request = parseResponsesRequest(await readJson(req));
+    const resolved = resolveModel(request.model, deps());
+    trace.target = `${resolved.providerId}/${resolved.logicalId}`;
+    const events = await startUpstream(request, resolved, signal);
+    const id = `resp_${randomUUID().replaceAll("-", "")}`;
+    const created = Math.floor(Date.now() / 1e3);
+    if (!request.stream) {
+      const message = await collectFinal(events);
+      sendJson(res, 200, toResponse(message, { id, created, model: request.model }));
+      return;
+    }
+    const state = createResponsesStreamState({ id, created, model: request.model });
+    await pipeSse(res, events, {
+      frames: (event) => responsesEvents(event, state),
+      errorFrame: (message) => ({ type: "error", code: "upstream_error", message, param: null }),
+      eventName: (frame) => isRecord2(frame) && typeof frame.type === "string" ? frame.type : void 0
+    });
+  }
+  async function handleEmbeddings(req, res, signal, trace) {
+    const body = await readJson(req);
+    if (!isRecord2(body) || typeof body.model !== "string" || body.model === "") {
+      throw new ModelEndpointError(400, "`model` is required", "missing_model");
+    }
+    const resolved = resolveModel(body.model, deps());
+    trace.target = `${resolved.providerId}/${resolved.logicalId}`;
+    if (!EMBEDDING_SURFACES.has(resolved.model.api)) {
+      throw new ModelEndpointError(
+        501,
+        `embeddings not supported for surface ${resolved.model.api}`,
+        "embeddings_unsupported"
+      );
+    }
+    const headers = {
+      "content-type": "application/json",
+      ...resolved.headers
+    };
+    if (resolved.apiKey) headers.authorization = `Bearer ${resolved.apiKey}`;
+    let upstream;
+    try {
+      upstream = await (options.fetch ?? globalThis.fetch)(`${resolved.model.baseUrl}/embeddings`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ ...body, model: resolved.model.id }),
+        signal
+      });
+    } catch (cause) {
+      if (signal.aborted) return;
+      throw new ModelEndpointError(
+        502,
+        `embeddings upstream unreachable: ${errorText(cause)}`,
+        "upstream_unreachable"
+      );
+    }
+    const payload = Buffer.from(await upstream.arrayBuffer());
+    res.writeHead(upstream.status, {
+      "content-type": upstream.headers.get("content-type") ?? "application/json",
+      "content-length": payload.length
+    });
+    res.end(payload);
+  }
+  async function dispatch(req, res, signal, path, trace) {
+    if (!path.startsWith("/v1/")) throw notFound(path);
+    authenticate(req);
+    switch (`${req.method} ${path}`) {
+      case "GET /v1/models":
+        sendJson(res, 200, {
+          object: "list",
+          data: listModels(options.getRegistry()).map((m) => ({
+            id: m.id,
+            object: "model",
+            created: 0,
+            owned_by: m.owned_by
+          }))
+        });
+        return;
+      case "POST /v1/chat/completions":
+        return handleChat(req, res, signal, trace);
+      case "POST /v1/responses":
+        return handleResponses(req, res, signal, trace);
+      case "POST /v1/embeddings":
+        return handleEmbeddings(req, res, signal, trace);
+      default:
+        throw notFound(path);
+    }
+  }
+  async function handle(req, res) {
+    const started = performance.now();
+    const controller = new AbortController();
+    res.on("close", () => {
+      if (!res.writableFinished) controller.abort();
+    });
+    const trace = {};
+    let path = req.url ?? "/";
+    try {
+      path = requestPath(req);
+      await dispatch(req, res, controller.signal, path, trace);
+    } catch (err) {
+      if (!(err instanceof ModelEndpointError)) {
+        log(
+          `error ${req.method} ${path}: ${err instanceof Error ? err.stack ?? err.message : String(err)}`
+        );
+      }
+      sendError(res, err);
+    } finally {
+      const ms = Math.round(performance.now() - started);
+      log(`${req.method} ${path} ${trace.target ?? "-"} ${res.statusCode} ${ms}ms`);
+    }
+  }
+  const server = createServer((req, res) => {
+    void handle(req, res);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? 0, host, () => {
+      server.off("error", reject);
+      resolve();
+    });
+  });
+  const address = server.address();
+  const hostPart = host.includes(":") ? `[${host}]` : host;
+  return {
+    url: `http://${hostPart}:${address.port}/v1`,
+    port: address.port,
+    token: options.token,
+    close: () => new Promise((resolve, reject) => {
+      server.close((err) => err ? reject(err) : resolve());
+      server.closeAllConnections?.();
+    })
+  };
+}
+async function loadPi() {
+  try {
+    return await import('@earendil-works/pi-ai');
+  } catch (cause) {
+    throw new ModelEndpointError(
+      500,
+      `the model endpoint needs @earendil-works/pi-ai \u2014 install it (${errorText(cause)})`,
+      "pi_ai_not_installed",
+      "server_error"
+    );
+  }
+}
+async function defaultLoadApi(surface) {
+  if (!/^[a-z0-9-]+$/.test(surface)) throw new Error(`invalid surface '${surface}'`);
+  return await import(
+    /* @vite-ignore */
+    `@earendil-works/pi-ai/api/${surface}`
+  );
+}
+async function collectFinal(events) {
+  for await (const event of events) {
+    if (event.type === "done") return event.message;
+    if (event.type === "error") throw upstreamFailure(event.error);
+  }
+  throw new ModelEndpointError(
+    502,
+    "upstream ended without a final message",
+    "upstream_incomplete"
+  );
+}
+function upstreamFailure(message) {
+  return new ModelEndpointError(
+    502,
+    message.errorMessage ?? `upstream ${message.stopReason}`,
+    "upstream_error"
+  );
+}
+async function pipeSse(res, events, pipe) {
+  let sse;
+  const sendAll = async (frames) => {
+    for (const frame of frames) await sse?.send(frame, pipe.eventName?.(frame));
+  };
+  try {
+    for await (const event of events) {
+      if (!sse) {
+        if (event.type === "error") throw upstreamFailure(event.error);
+        sse = openSse(res);
+      }
+      if (event.type === "error") {
+        await sendAll([pipe.errorFrame(event.error.errorMessage ?? `upstream ${event.reason}`)]);
+        break;
+      }
+      await sendAll(pipe.frames(event));
+    }
+  } catch (err) {
+    if (!sse) throw err;
+    await sendAll([pipe.errorFrame(errorText(err))]);
+  }
+  if (!sse)
+    throw new ModelEndpointError(502, "upstream ended without events", "upstream_incomplete");
+  if (pipe.terminator) await sse.raw(pipe.terminator);
+  res.end();
+}
+function openSse(res) {
+  res.writeHead(200, {
+    "content-type": "text/event-stream",
+    "cache-control": "no-cache",
+    connection: "keep-alive"
+  });
+  res.flushHeaders();
+  const write = async (text) => {
+    if (res.destroyed || res.writableEnded) return;
+    if (res.write(text)) return;
+    await new Promise((resolve) => {
+      const done = () => {
+        res.off("drain", done);
+        res.off("close", done);
+        resolve();
+      };
+      res.once("drain", done);
+      res.once("close", done);
+    });
+  };
+  return {
+    send: (frame, eventName) => write(`${eventName ? `event: ${eventName}
+` : ""}data: ${JSON.stringify(frame)}
+
+`),
+    raw: (data) => write(`data: ${data}
+
+`)
+  };
+}
+function sendJson(res, status, body) {
+  if (res.writableEnded) return;
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(payload)
+  });
+  res.end(payload);
+}
+function sendError(res, err) {
+  if (res.writableEnded || res.destroyed) return;
+  if (res.headersSent) {
+    res.end();
+    return;
+  }
+  const failure = err instanceof ModelEndpointError ? err : new ModelEndpointError(500, "internal server error", void 0, "server_error");
+  if (failure.status === 413) res.setHeader("connection", "close");
+  sendJson(res, failure.status, {
+    error: {
+      message: failure.message,
+      type: failure.type,
+      ...failure.code !== void 0 ? { code: failure.code } : {}
+    }
+  });
+}
+function notFound(path) {
+  return new ModelEndpointError(404, `unknown route '${path}'`, void 0, "invalid_request_error");
+}
+function requestPath(req) {
+  if (!URL.canParse(req.url ?? "/", "http://localhost")) {
+    throw new ModelEndpointError(400, "invalid request target");
+  }
+  const path = new URL(req.url ?? "/", "http://localhost").pathname;
+  return path.length > 1 ? path.replace(/\/+$/, "") : path;
+}
+async function readJson(req) {
+  const tooLarge = () => new ModelEndpointError(413, `request body exceeds ${MAX_BODY_BYTES} bytes`, "body_too_large");
+  if (Number(req.headers["content-length"]) > MAX_BODY_BYTES) throw tooLarge();
+  const chunks = [];
+  let size = 0;
+  for await (const chunk2 of req) {
+    const buffer = chunk2;
+    size += buffer.length;
+    if (size > MAX_BODY_BYTES) throw tooLarge();
+    chunks.push(buffer);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (text.trim() === "") throw new ModelEndpointError(400, "request body is empty", "empty_body");
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ModelEndpointError(400, "request body is not valid JSON", "invalid_json");
+  }
+}
+function digest(value) {
+  return createHash("sha256").update(value).digest();
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function errorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+
+export { ModelEndpointError, listModels, resolveModel, startModelEndpoint };
+//# sourceMappingURL=chunk-OKQXY6FS.js.map
+//# sourceMappingURL=chunk-OKQXY6FS.js.map