@skaile/workspaces 6.8.1 → 6.9.0

package/dist/{chunk-REAF7ZFA.js → chunk-T5EIWWEJ.js}

@@ -1,11 +1,13 @@
-import { selectableEntries, entryModelIds, entrySurface, entryBaseUrl } from './chunk-I6XH46Q6.js';
-import { entryCredentialValue } from './chunk-SILFO5RY.js';
-import { listenWithProbe, loadHarnessSdkSubpath, loadHarnessSdk } from './chunk-TMJBEGS4.js';
+import { selectableEntries, entryModelIds, entrySurface, entryBaseUrl } from './chunk-4WB4KSSQ.js';
+import { entryCredentialValue } from './chunk-SQMDFM4N.js';
+import { buildCredentialHeaders } from './chunk-6UP2EDFN.js';
+import { listenWithProbe, loadHarnessSdkSubpath, loadHarnessSdk } from './chunk-4KPQ6ILH.js';
 import { parseModelRef } from './chunk-RXGPFAMN.js';
 import { createHash, timingSafeEqual, randomUUID } from 'crypto';
 import { createServer } from 'http';
 
 // model-endpoint/src/types.ts
+var AGENT_MODEL_ID = "skaile-agent";
 var ModelEndpointError = class extends Error {
   status;
   type;
@@ -35,16 +37,17 @@ function piBaseUrl(_surface, registryBaseUrl) {
 }
 function resolveModel(selector, deps) {
   assertKnownProviderPrefix(selector, deps);
-  const ref = parseModelRef(selector, deps.registry, deps.roles);
-  if (!ref || ref.modelId === void 0) {
+  const parsed = parseModelRef(selector, deps.registry, deps.roles);
+  if (!parsed || parsed.modelId === void 0) {
     throw new ModelEndpointError(404, `model '${selector}' not found`, "model_not_found");
   }
+  const logicalId = parsed.modelId;
+  const ref = parsed.fallback ? placeUndeclaredBareId(selector, logicalId, parsed, deps) : parsed;
   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(
@@ -86,6 +89,24 @@ function resolveModel(selector, deps) {
     ...entry.headers ? { headers: entry.headers } : {}
   };
 }
+function needsUpstreamModels(selector, deps) {
+  const ref = parseModelRef(selector, deps.registry, deps.roles);
+  return ref?.modelId !== void 0 && ref.fallback === true;
+}
+function placeUndeclaredBareId(selector, modelId, ref, deps) {
+  const owner = selectableEntries(deps.registry).find(
+    ([id, entry]) => entryModelIds(entry).length === 0 && deps.upstreamModels?.[id]?.has(modelId)
+  );
+  if (owner) {
+    return { ...ref, providerId: owner[0], providerModelId: modelId, fallback: void 0 };
+  }
+  const providers = selectableEntries(deps.registry).map(([id]) => id);
+  throw new ModelEndpointError(
+    404,
+    `model '${selector}' not found: no provider of this endpoint declares or lists '${modelId}'; name it '<provider>/<model>' (providers: ${providers.join(", ")}) or add it to a model_map`,
+    "model_not_found"
+  );
+}
 function assertKnownProviderPrefix(selector, deps) {
   let target = selector.trim();
   if (target.startsWith("@")) target = deps.roles?.[target.slice(1)]?.trim() ?? "";
@@ -111,14 +132,195 @@ function isKeyless(entry) {
 function listPassThroughProviders(registry) {
   return selectableEntries(registry).filter(([, entry]) => entryModelIds(entry).length === 0).map(([providerId]) => providerId);
 }
-function listModels(registry) {
-  return selectableEntries(registry).flatMap(
-    ([providerId, entry]) => entryModelIds(entry).map(([logicalId]) => ({
-      id: `${providerId}/${logicalId}`,
-      owned_by: providerId
-    }))
+function listModels(registry, upstreamModels = {}) {
+  return selectableEntries(registry).flatMap(([providerId, entry]) => {
+    const ids = entryModelIds(entry).map(([logicalId]) => logicalId);
+    if (ids.length === 0) ids.push(...upstreamModels[providerId] ?? []);
+    return ids.map((logicalId) => ({ id: `${providerId}/${logicalId}`, owned_by: providerId }));
+  });
+}
+
+// model-endpoint/src/openai-agent.ts
+var MAX_INPUT_CHARS = 200;
+function agentPromptText(request) {
+  const messages = request.context.messages;
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (message?.role !== "user") continue;
+    if (typeof message.content === "string") return message.content;
+    let text = "";
+    for (const part of message.content) {
+      if (part.type === "image") {
+        throw new ModelEndpointError(400, "skaile-agent takes text only", "unsupported_content");
+      }
+      text += part.text;
+    }
+    return text;
+  }
+  throw new ModelEndpointError(
+    400,
+    "messages must contain a message with role 'user'",
+    "missing_user_message"
   );
 }
+function truncated(text) {
+  return text.length > MAX_INPUT_CHARS ? `${text.slice(0, MAX_INPUT_CHARS)}\u2026` : text;
+}
+function activityLine(event) {
+  switch (event.type) {
+    case "tool_call": {
+      const input = JSON.stringify(event.input);
+      return `\u2192 ${event.tool}${input === void 0 ? "" : ` ${truncated(input)}`}
+`;
+    }
+    case "tool_result":
+      return `\u2190 ${event.tool}
+`;
+    case "error":
+      return event.fatal ? void 0 : `! ${event.message}
+`;
+    default:
+      return void 0;
+  }
+}
+function questionText(event) {
+  const options = event.options ?? [];
+  if (options.length === 0) return event.question;
+  return `${event.question}
+${options.map((option, i) => `${i + 1}. ${option}`).join("\n")}`;
+}
+function endsAgentTurn(event) {
+  return event.type === "finished" || event.type === "question";
+}
+function toAgentUsage(finished) {
+  const tokens = finished?.tokens;
+  const prompt = tokens?.inputTokens ?? 0;
+  const completion = tokens?.outputTokens ?? 0;
+  const usage = {
+    prompt_tokens: prompt,
+    completion_tokens: completion,
+    total_tokens: tokens?.totalTokens ?? prompt + completion,
+    prompt_tokens_details: { cached_tokens: tokens?.cacheReadTokens ?? 0 }
+  };
+  if (tokens?.reasoningTokens !== void 0) {
+    usage.completion_tokens_details = { reasoning_tokens: tokens.reasoningTokens };
+  }
+  if (finished !== void 0 && finished.costUsd > 0) usage.cost = finished.costUsd;
+  return usage;
+}
+async function toAgentCompletion(events, meta) {
+  let content = "";
+  let reasoning = "";
+  let failure;
+  let finished;
+  for await (const event of events) {
+    if (event.type === "text") {
+      content += event.content;
+    } else if (event.type === "text_retract") {
+      if (event.content.length > 0 && content.endsWith(event.content)) {
+        content = content.slice(0, -event.content.length);
+      }
+    } else if (event.type === "error" && event.fatal) {
+      failure ??= event.message;
+    } else if (event.type === "question") {
+      content += content.length > 0 ? `
+${questionText(event)}` : questionText(event);
+    } else if (event.type === "finished") {
+      finished = event;
+    } else {
+      reasoning += activityLine(event) ?? "";
+    }
+    if (endsAgentTurn(event)) break;
+  }
+  if (failure !== void 0) {
+    throw new ModelEndpointError(502, failure, "turn_failed", "upstream_error");
+  }
+  return {
+    id: meta.id,
+    object: "chat.completion",
+    created: meta.created,
+    model: meta.model,
+    choices: [
+      {
+        index: 0,
+        message: {
+          role: "assistant",
+          content: content.length > 0 ? content : null,
+          ...reasoning.length > 0 ? { reasoning_content: reasoning } : {}
+        },
+        finish_reason: "stop"
+      }
+    ],
+    usage: toAgentUsage(finished)
+  };
+}
+function createAgentStreamState(init) {
+  return { ...init, started: false, closed: false, hasContent: false };
+}
+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 closingChunks(state, finished) {
+  state.closed = true;
+  const chunks = [chunk(state, {}, "stop")];
+  if (state.includeUsage) {
+    chunks.push({
+      id: state.id,
+      object: "chat.completion.chunk",
+      created: state.created,
+      model: state.model,
+      choices: [],
+      usage: toAgentUsage(finished)
+    });
+  }
+  return chunks;
+}
+function agentDeltas(event, state) {
+  switch (event.type) {
+    case "text":
+      if (event.content.length === 0) return [];
+      state.hasContent = true;
+      return [chunk(state, { content: event.content })];
+    case "text_retract":
+      return [chunk(state, { reasoning_content: `~ retracted ${event.content.length} chars
+` })];
+    case "question": {
+      const text = questionText(event);
+      const content = state.hasContent ? `
+${text}` : text;
+      return [chunk(state, { content }), ...closingChunks(state, void 0)];
+    }
+    case "finished":
+      return closingChunks(state, event);
+    default: {
+      if (event.type === "error" && event.fatal) {
+        state.error ??= event.message;
+        return [];
+      }
+      const line = activityLine(event);
+      return line === void 0 ? [] : [chunk(state, { reasoning_content: line })];
+    }
+  }
+}
+function agentCompletionChunks(event, state) {
+  const chunks = agentDeltas(event, state);
+  if (chunks.length === 0 || state.started) return chunks;
+  state.started = true;
+  return [chunk(state, { role: "assistant", content: "" }), ...chunks];
+}
+function agentCompletionEnd(state) {
+  if (state.closed) return [];
+  const chunks = closingChunks(state, void 0);
+  if (state.started) return chunks;
+  state.started = true;
+  return [chunk(state, { role: "assistant", content: "" }), ...chunks];
+}
 
 // model-endpoint/src/openai-shared.ts
 var THINKING_LEVELS = [
@@ -528,7 +730,7 @@ function toChatCompletion(message, meta, cost) {
 function createChatStreamState(init) {
   return { ...init, nextToolIndex: 0, toolIndexByContent: /* @__PURE__ */ new Map() };
 }
-function chunk(state, delta, finish = null) {
+function chunk2(state, delta, finish = null) {
   return {
     id: state.id,
     object: "chat.completion.chunk",
@@ -540,11 +742,11 @@ function chunk(state, delta, finish = null) {
 function chatCompletionChunks(event, state) {
   switch (event.type) {
     case "start":
-      return [chunk(state, { role: "assistant", content: "" })];
+      return [chunk2(state, { role: "assistant", content: "" })];
     case "text_delta":
-      return event.delta.length > 0 ? [chunk(state, { content: event.delta })] : [];
+      return event.delta.length > 0 ? [chunk2(state, { content: event.delta })] : [];
     case "thinking_delta":
-      return event.delta.length > 0 ? [chunk(state, { reasoning_content: event.delta })] : [];
+      return event.delta.length > 0 ? [chunk2(state, { reasoning_content: event.delta })] : [];
     case "toolcall_start":
       state.toolIndexByContent.set(event.contentIndex, state.nextToolIndex++);
       return [];
@@ -555,7 +757,7 @@ function chatCompletionChunks(event, state) {
         state.toolIndexByContent.set(event.contentIndex, index);
       }
       return [
-        chunk(state, {
+        chunk2(state, {
           tool_calls: [
             {
               index,
@@ -571,7 +773,7 @@ function chatCompletionChunks(event, state) {
       ];
     }
     case "done": {
-      const chunks = [chunk(state, {}, finishReason(event.reason, void 0))];
+      const chunks = [chunk2(state, {}, finishReason(event.reason, void 0))];
       if (state.includeUsage) {
         chunks.push({
           id: state.id,
@@ -1025,6 +1227,73 @@ function responsesEvents(event, state) {
   }
 }
 
+// model-endpoint/src/upstream-models.ts
+var LIST_TIMEOUT_MS = 5e3;
+var CACHE_TTL_MS = 6e4;
+var ANTHROPIC_VERSION = "2023-06-01";
+var UpstreamModelCache = class {
+  cache = /* @__PURE__ */ new Map();
+  async list(registry, lookupEnv, fetchFn) {
+    const open = selectableEntries(registry).filter(
+      ([, entry]) => entryModelIds(entry).length === 0
+    );
+    const lists = await Promise.all(
+      open.map(async ([providerId, entry]) => {
+        const surface = entrySurface(entry);
+        const baseUrl = entryBaseUrl(entry);
+        if (!surface || !baseUrl) return [providerId, /* @__PURE__ */ new Set()];
+        const key = `${providerId}
+${baseUrl}`;
+        const hit = this.cache.get(key);
+        if (hit && Date.now() - hit.at < CACHE_TTL_MS) return [providerId, hit.ids];
+        const apiKey = entryCredentialValue(providerId, entry, {
+          env: lookupEnv,
+          allowCommand: false
+        });
+        const ids = await fetchIds(
+          surface,
+          baseUrl,
+          buildCredentialHeaders(entry, apiKey),
+          entry.headers,
+          fetchFn
+        );
+        if (!ids) return [providerId, /* @__PURE__ */ new Set()];
+        this.cache.set(key, { at: Date.now(), ids });
+        return [providerId, ids];
+      })
+    );
+    return Object.fromEntries(lists);
+  }
+};
+async function fetchIds(surface, baseUrl, credentialHeaders, entryHeaders, fetchFn) {
+  const anthropic = surface === "anthropic-messages";
+  if (!anthropic && surface !== "openai-completions" && surface !== "openai-responses") {
+    return void 0;
+  }
+  const url = anthropic ? `${baseUrl}/v1/models?limit=1000` : `${baseUrl}/models`;
+  const headers = {
+    accept: "application/json",
+    ...entryHeaders,
+    ...credentialHeaders
+  };
+  if (anthropic) headers["anthropic-version"] = ANTHROPIC_VERSION;
+  try {
+    const res = await fetchFn(url, { headers, signal: AbortSignal.timeout(LIST_TIMEOUT_MS) });
+    if (!res.ok) return void 0;
+    const body = await res.json();
+    const data = body?.data;
+    if (!Array.isArray(data)) return void 0;
+    return new Set(
+      data.flatMap((item) => {
+        const id = item?.id;
+        return typeof id === "string" && id !== "" ? [id] : [];
+      })
+    );
+  } catch {
+    return void 0;
+  }
+}
+
 // model-endpoint/src/usage-cost.ts
 function costOf(payload) {
   if (typeof payload !== "object" || payload === null || !("usage" in payload)) return void 0;
@@ -1098,11 +1367,32 @@ async function startModelEndpoint(options) {
   const projectDir = options.projectDir ?? process.cwd();
   const loadApi = options.loadApi ?? ((surface) => defaultLoadApi(surface, projectDir));
   const tokenDigest = digest(options.token);
+  const upstreamModels = new UpstreamModelCache();
+  async function resolveWithUpstream(selector) {
+    const current = deps();
+    if (needsUpstreamModels(selector, current)) {
+      current.upstreamModels = await upstreamModels.list(
+        current.registry,
+        current.lookupEnv,
+        options.fetch ?? globalThis.fetch
+      );
+    }
+    return resolveModel(selector, current);
+  }
   const deps = () => ({
     registry: options.getRegistry(),
     lookupEnv: options.getLookupEnv(),
     roles: options.getRoles?.()
   });
+  function rejectAgentSurface(model) {
+    if (model === AGENT_MODEL_ID && options.getAgentLoop?.()) {
+      throw new ModelEndpointError(
+        400,
+        `${AGENT_MODEL_ID} is served on /v1/chat/completions only`,
+        "agent_model_unsupported_surface"
+      );
+    }
+  }
   function authenticate(req) {
     const match = /^Bearer\s+(.+)$/i.exec(req.headers.authorization ?? "");
     if (!match || !timingSafeEqual(digest(match[1] ?? ""), tokenDigest)) {
@@ -1151,7 +1441,9 @@ async function startModelEndpoint(options) {
   }
   async function handleChat(req, res, signal, trace) {
     const request = parseChatCompletionRequest(await readJson(req));
-    const resolved = resolveModel(request.model, deps());
+    const agentLoop = request.model === AGENT_MODEL_ID ? options.getAgentLoop?.() : void 0;
+    if (agentLoop) return handleAgentChat(res, request, agentLoop, signal, trace);
+    const resolved = await resolveWithUpstream(request.model);
     trace.target = `${resolved.providerId}/${resolved.logicalId}`;
     const { events, cost } = await startUpstream(request, resolved, signal, true);
     const id = `chatcmpl-${randomUUID().replaceAll("-", "")}`;
@@ -1176,13 +1468,46 @@ async function startModelEndpoint(options) {
         if (event.type === "done" && state.includeUsage) state.cost = await cost();
         return chatCompletionChunks(event, state);
       },
-      errorFrame: (message) => ({ error: { message, type: "upstream_error" } }),
+      errorFrame: upstreamErrorFrame,
       terminator: "[DONE]"
     });
   }
+  async function handleAgentChat(res, request, loop, signal, trace) {
+    trace.target = AGENT_MODEL_ID;
+    const text = agentPromptText(request);
+    const run = await loop.prompt({ text, requestId: randomUUID() });
+    const abort = () => {
+      run.abort().catch((cause) => log(`agent abort failed: ${errorText(cause)}`));
+    };
+    if (signal.aborted) abort();
+    else signal.addEventListener("abort", abort, { once: true });
+    try {
+      const id = `chatcmpl-${randomUUID().replaceAll("-", "")}`;
+      const created = Math.floor(Date.now() / 1e3);
+      if (!request.stream) {
+        const completion = await toAgentCompletion(run.events, {
+          id,
+          created,
+          model: AGENT_MODEL_ID
+        });
+        sendJson(res, 200, completion);
+        return;
+      }
+      const state = createAgentStreamState({
+        id,
+        created,
+        model: AGENT_MODEL_ID,
+        includeUsage: request.includeUsage
+      });
+      await pipeAgentSse(res, run.events, state);
+    } finally {
+      signal.removeEventListener("abort", abort);
+    }
+  }
   async function handleResponses(req, res, signal, trace) {
     const request = parseResponsesRequest(await readJson(req));
-    const resolved = resolveModel(request.model, deps());
+    rejectAgentSurface(request.model);
+    const resolved = await resolveWithUpstream(request.model);
     trace.target = `${resolved.providerId}/${resolved.logicalId}`;
     const { events } = await startUpstream(request, resolved, signal);
     const id = `resp_${randomUUID().replaceAll("-", "")}`;
@@ -1204,7 +1529,8 @@ async function startModelEndpoint(options) {
     if (!isRecord2(body) || typeof body.model !== "string" || body.model === "") {
       throw new ModelEndpointError(400, "`model` is required", "missing_model");
     }
-    const resolved = resolveModel(body.model, deps());
+    rejectAgentSurface(body.model);
+    const resolved = await resolveWithUpstream(body.model);
     trace.target = `${resolved.providerId}/${resolved.logicalId}`;
     if (!EMBEDDING_SURFACES.has(resolved.model.api)) {
       throw new ModelEndpointError(
@@ -1245,19 +1571,30 @@ async function startModelEndpoint(options) {
     if (!path.startsWith("/v1/")) throw notFound(path);
     authenticate(req);
     switch (`${req.method} ${path}`) {
-      case "GET /v1/models":
+      case "GET /v1/models": {
+        const registry = options.getRegistry();
+        const upstream = await upstreamModels.list(
+          registry,
+          options.getLookupEnv(),
+          options.fetch ?? globalThis.fetch
+        );
         sendJson(res, 200, {
           object: "list",
-          data: listModels(options.getRegistry()).map((m) => ({
-            id: m.id,
-            object: "model",
-            created: 0,
-            owned_by: m.owned_by
-          })),
-          // Entries that declare no models forward any `<id>/<model>`: nothing to list.
-          pass_through_providers: listPassThroughProviders(options.getRegistry())
+          data: [
+            ...listModels(registry, upstream).map((m) => ({
+              id: m.id,
+              object: "model",
+              created: 0,
+              owned_by: m.owned_by
+            })),
+            ...options.getAgentLoop?.() ? [{ id: AGENT_MODEL_ID, object: "model", created: 0, owned_by: "skaile" }] : []
+          ],
+          // Entries that declare no models forward any `<id>/<model>`, also one their upstream
+          // does not list.
+          pass_through_providers: listPassThroughProviders(registry)
         });
         return;
+      }
       case "POST /v1/chat/completions":
         return handleChat(req, res, signal, trace);
       case "POST /v1/responses":
@@ -1404,6 +1741,31 @@ async function pipeSse(res, events, pipe) {
   if (pipe.terminator) await sse.raw(pipe.terminator);
   res.end();
 }
+async function pipeAgentSse(res, events, state) {
+  let sse;
+  const sendAll = async (frames) => {
+    for (const frame of frames) {
+      sse ??= openSse(res);
+      await sse.send(frame);
+    }
+  };
+  try {
+    for await (const event of events) {
+      await sendAll(agentCompletionChunks(event, state));
+      if (endsAgentTurn(event)) break;
+    }
+    await sendAll(agentCompletionEnd(state));
+  } catch (err) {
+    if (!sse) throw err;
+    state.error ??= errorText(err);
+  }
+  if (state.error !== void 0) await sendAll([upstreamErrorFrame(state.error)]);
+  await sse?.raw("[DONE]");
+  res.end();
+}
+function upstreamErrorFrame(message) {
+  return { error: { message, type: "upstream_error" } };
+}
 function openSse(res) {
   res.writeHead(200, {
     "content-type": "text/event-stream",
@@ -1474,8 +1836,8 @@ async function readJson(req) {
   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;
+  for await (const chunk3 of req) {
+    const buffer = chunk3;
     size += buffer.length;
     if (size > MAX_BODY_BYTES) throw tooLarge();
     chunks.push(buffer);
@@ -1498,6 +1860,6 @@ function errorText(err) {
   return err instanceof Error ? err.message : String(err);
 }
 
-export { ModelEndpointError, checkPiAiInstalled, listModels, resolveModel, startModelEndpoint };
-//# sourceMappingURL=chunk-REAF7ZFA.js.map
-//# sourceMappingURL=chunk-REAF7ZFA.js.map
+export { AGENT_MODEL_ID, ModelEndpointError, checkPiAiInstalled, listModels, resolveModel, startModelEndpoint };
+//# sourceMappingURL=chunk-T5EIWWEJ.js.map
+//# sourceMappingURL=chunk-T5EIWWEJ.js.map