@theokit/sdk 4.8.0 → 4.9.0

package/dist/cron.js

@@ -12950,6 +12950,192 @@ function assistantMessage(message) {
   return result;
 }
 
+// src/internal/llm/responses.ts
+function messageToInputItems(message) {
+  const items = [];
+  if (message.role === "user") {
+    const content = [];
+    for (const part of message.content) {
+      if (part.type === "text") {
+        content.push({ type: "input_text", text: part.text });
+      } else if (part.type === "image") {
+        const url = part.source.type === "base64" ? `data:${part.source.media_type};base64,${part.source.data}` : part.source.url;
+        content.push({ type: "input_image", image_url: url });
+      } else if (part.type === "tool_result") {
+        items.push({
+          type: "function_call_output",
+          call_id: part.toolUseId,
+          output: toStringToolResultContent(part.content, "openai-responses")
+        });
+      }
+    }
+    if (content.length > 0) items.push({ role: "user", content });
+    return items;
+  }
+  if (message.role === "assistant") {
+    const content = [];
+    for (const part of message.content) {
+      if (part.type === "text") {
+        content.push({ type: "output_text", text: part.text });
+      } else if (part.type === "tool_use") {
+        items.push({
+          type: "function_call",
+          call_id: part.id,
+          name: part.name,
+          arguments: JSON.stringify(part.input)
+        });
+      }
+    }
+    if (content.length > 0) items.push({ role: "assistant", content });
+    return items;
+  }
+  const text = message.content.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+  if (text.length > 0) items.push({ role: "system", content: text });
+  return items;
+}
+function buildResponsesBody(request) {
+  const input = [];
+  for (const message of request.messages) {
+    for (const item of messageToInputItems(message)) input.push(item);
+  }
+  const body = { model: request.model, input, stream: true, store: false };
+  const instructions = collapseSystemText(request.system);
+  if (instructions.length > 0) body.instructions = instructions;
+  if (request.maxTokens !== void 0) body.max_output_tokens = request.maxTokens;
+  if (request.temperature !== void 0) body.temperature = request.temperature;
+  const tools = (request.tools ?? []).map((tool) => ({
+    type: "function",
+    name: tool.name,
+    description: tool.description,
+    parameters: tool.inputSchema,
+    strict: false
+  }));
+  if (tools.length > 0) body.tools = tools;
+  if (request.reasoning !== void 0) body.reasoning = { effort: request.reasoning.effort };
+  return body;
+}
+var ResponsesApiClient = class {
+  constructor(options) {
+    this.options = options;
+    this.name = options.providerName ?? "openai-responses";
+    this.baseUrl = (options.baseUrl ?? "https://api.openai.com/v1").replace(/\/+$/, "");
+    this.fetchImpl = options.fetch ?? fetch;
+  }
+  options;
+  name;
+  baseUrl;
+  fetchImpl;
+  // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: the SSE dispatch (text / reasoning / tool-call add+delta+done / terminal+usage / error) is one cohesive state machine, mirroring OpenAIStreamAccumulator.consume.
+  async *stream(request, signal) {
+    const providerId = this.options.providerName ?? "openai";
+    const headers = {
+      "content-type": "application/json",
+      accept: "text/event-stream",
+      authorization: `Bearer ${this.options.apiKey}`,
+      ...this.options.extraHeaders ?? {}
+    };
+    const url = `${this.baseUrl}/responses`;
+    const response = await this.fetchImpl(url, {
+      method: "POST",
+      signal,
+      headers,
+      body: JSON.stringify(buildResponsesBody(request))
+    });
+    if (!response.ok) {
+      const text2 = await response.text().catch(() => "");
+      let body = text2;
+      try {
+        body = JSON.parse(text2);
+      } catch {
+      }
+      throw mapOpenAICompatibleError({
+        providerId,
+        status: response.status,
+        body,
+        headers: response.headers,
+        endpoint: "/responses"
+      });
+    }
+    let text = "";
+    const toolCalls = [];
+    let stopReason = "end_turn";
+    let inputTokens;
+    let outputTokens;
+    let reasoningTokens;
+    const pending = {};
+    if (response.body !== null) {
+      for await (const record of parseSseStream(response.body, signal)) {
+        if (record.data === "[DONE]") break;
+        let event;
+        try {
+          event = JSON.parse(record.data);
+        } catch {
+          continue;
+        }
+        const t = event.type;
+        if (t === "response.output_text.delta") {
+          const d = event.delta ?? "";
+          if (d.length > 0) {
+            text += d;
+            yield { type: "text_delta", text: d };
+          }
+        } else if (t === "response.reasoning_summary_text.delta" || t === "response.reasoning_text.delta") {
+          const d = event.delta ?? "";
+          if (d.length > 0) yield { type: "reasoning_delta", text: d };
+        } else if (t === "response.output_item.added" && event.item?.type === "function_call") {
+          const id = event.item.id ?? event.item.call_id ?? "call-0";
+          pending[id] = {
+            callId: event.item.call_id ?? id,
+            name: event.item.name ?? "",
+            args: event.item.arguments ?? ""
+          };
+        } else if (t === "response.function_call_arguments.delta") {
+          const c = event.item_id !== void 0 ? pending[event.item_id] : void 0;
+          if (c !== void 0) c.args += event.delta ?? "";
+        } else if (t === "response.output_item.done" && event.item?.type === "function_call") {
+          const id = event.item.id ?? event.item.call_id ?? "call-0";
+          const c = pending[id] ?? {
+            callId: event.item.call_id ?? id,
+            name: event.item.name ?? "",
+            args: event.item.arguments ?? ""
+          };
+          const rawArgs = event.item.arguments ?? c.args;
+          const call = {
+            type: "tool_use",
+            id: c.callId,
+            name: c.name.length > 0 ? c.name : event.item.name ?? "",
+            input: parseToolArguments(rawArgs)
+          };
+          toolCalls.push(call);
+          delete pending[id];
+          yield { type: "tool_use", id: call.id, name: call.name, input: call.input };
+        } else if (t === "response.completed" || t === "response.incomplete") {
+          const usage = event.response?.usage;
+          if (usage !== void 0) {
+            inputTokens = usage.input_tokens;
+            outputTokens = usage.output_tokens;
+            reasoningTokens = usage.output_tokens_details?.reasoning_tokens;
+          }
+          stopReason = t === "response.incomplete" ? "max_tokens" : "end_turn";
+        } else if (t === "response.failed" || t === "error") {
+          const msg = event.response?.error?.message ?? event.message ?? "responses stream failed";
+          yield { type: "error", message: msg };
+          throw mapOpenAICompatibleError({
+            providerId,
+            status: 502,
+            body: { error: { message: msg } },
+            headers: response.headers,
+            endpoint: "/responses"
+          });
+        }
+      }
+    }
+    if (toolCalls.length > 0 && stopReason === "end_turn") stopReason = "tool_use";
+    yield { type: "stop", reason: stopReason };
+    return makeLlmFinish({ stopReason, text, toolCalls, inputTokens, outputTokens, reasoningTokens });
+  }
+};
+
 // src/internal/llm/pool-aware-client.ts
 init_errors();
 
@@ -13518,6 +13704,14 @@ function selectTransport(profile, apiKey) {
     const realKey = apiKey === "__bedrock_lazy_token__" ? void 0 : apiKey;
     return new BedrockAnthropicClient(realKey !== void 0 ? { apiKey: realKey } : {});
   }
+  if (profile.apiMode === "responses_api") {
+    return new ResponsesApiClient({
+      apiKey,
+      ...profile.baseUrl !== void 0 ? { baseUrl: profile.baseUrl } : {},
+      ...profile.extraHeaders !== void 0 ? { extraHeaders: profile.extraHeaders } : {},
+      providerName: profile.name
+    });
+  }
   throw new ConfigurationError(
     `Provider "${profile.name}" requires apiMode "${profile.apiMode}" but no transport is registered. Install a third-party transport plugin (@theokit-transport-${profile.apiMode}) or use a provider with apiMode "chat_completions" or "anthropic_messages".`,
     { code: "transport_unavailable" }