@theokit/sdk 2.10.0 → 2.11.1

package/dist/eval.cjs

@@ -8343,6 +8343,14 @@ function buildAssistantEvent(inputs, text) {
     message: { role: "assistant", content: [{ type: "text", text }] }
   };
 }
+function buildThinkingEvent(inputs, text) {
+  return {
+    type: "thinking",
+    agent_id: inputs.agentId,
+    run_id: inputs.runId,
+    text
+  };
+}
 function buildAssistantTurn(text, toolCalls) {
   const content = [];
   if (text.length > 0) content.push({ type: "text", text });
@@ -8513,6 +8521,10 @@ ${additions}`;
 function toLlmTool(tool) {
   return { name: tool.name, description: tool.description, inputSchema: tool.inputSchema };
 }
+function reasoningEffortFromParams(params) {
+  const thinking = params?.find((p) => p.id === "thinking");
+  return thinking !== void 0 && thinking.value.length > 0 ? thinking.value : void 0;
+}
 async function streamLlmTurn(inputs, ctx) {
   const llmSpan = inputs.telemetry?.startSpan("llm.call", {
     "model.id": inputs.model.id ?? "auto",
@@ -8529,6 +8541,12 @@ async function streamLlmTurn(inputs, ctx) {
         );
         return effective !== void 0 ? { system: effective } : {};
       })(),
+      // issue #47: forward the reasoning effort from ModelSelection.params (the `thinking` param)
+      // so the provider produces reasoning. Absent param ⇒ no `reasoning` field (bare request).
+      ...(() => {
+        const effort = reasoningEffortFromParams(inputs.model.params);
+        return effort !== void 0 ? { reasoning: { effort } } : {};
+      })(),
       messages: ctx.messages,
       tools: ctx.tools.map(toLlmTool)
     },
@@ -8597,6 +8615,7 @@ function registerLoopError(ctx, cause) {
 }
 async function runCollectorLoop(generator, inputs, ctx) {
   let accumulatedText = "";
+  let reasoningText = "";
   let errored = false;
   let finishValue;
   while (true) {
@@ -8609,6 +8628,10 @@ async function runCollectorLoop(generator, inputs, ctx) {
       accumulatedText += next.value.text;
       await emitTextDeltaCallback(inputs, next.value.text);
     }
+    if (next.value.type === "reasoning_delta") {
+      reasoningText += next.value.text;
+      await emitReasoningDeltaCallback(inputs, next.value.text);
+    }
     if (next.value.type === "error") {
       registerLoopError(ctx, next.value);
       ctx.finalText = "";
@@ -8616,6 +8639,9 @@ async function runCollectorLoop(generator, inputs, ctx) {
       break;
     }
   }
+  if (reasoningText.length > 0) {
+    ctx.events.push(buildThinkingEvent(inputs, reasoningText));
+  }
   return { accumulatedText, errored, finishValue };
 }
 async function emitTextDeltaCallback(inputs, text) {
@@ -8627,6 +8653,15 @@ async function emitTextDeltaCallback(inputs, text) {
     "SendOptions.onDelta"
   );
 }
+async function emitReasoningDeltaCallback(inputs, text) {
+  if (inputs.onDelta === void 0) return;
+  const cb = inputs.onDelta;
+  await safeCall(
+    () => cb({ update: { type: "thinking-delta", text } }),
+    void 0,
+    "SendOptions.onDelta"
+  );
+}
 
 // src/internal/agent-loop/tool-dispatch.ts
 init_async_local_storage();
@@ -10940,7 +10975,7 @@ var OpenAIClient = class {
         method: "POST",
         signal,
         headers,
-        body: JSON.stringify(buildOpenAIBody(request))
+        body: JSON.stringify(buildOpenAIBody(request, providerId))
       });
     } catch (fetchErr) {
       const mapped = mapOllamaTransportError({
@@ -11002,6 +11037,10 @@ var OpenAIStreamAccumulator = class {
     const events = [];
     this.applyUsage(chunk.usage);
     for (const choice of chunk.choices ?? []) {
+      const reasoningEvent = this.applyReasoningDelta(
+        choice.delta?.reasoning ?? choice.delta?.reasoning_content
+      );
+      if (reasoningEvent !== void 0) events.push(reasoningEvent);
       const textEvent = this.applyContentDelta(choice.delta?.content);
       if (textEvent !== void 0) events.push(textEvent);
       this.mergeToolCallDeltas(choice.delta?.tool_calls);
@@ -11009,6 +11048,10 @@ var OpenAIStreamAccumulator = class {
     }
     return events;
   }
+  applyReasoningDelta(reasoning) {
+    if (typeof reasoning !== "string" || reasoning.length === 0) return void 0;
+    return { type: "reasoning_delta", text: reasoning };
+  }
   applyUsage(usage) {
     if (usage?.prompt_tokens !== void 0) this.inputTokens = usage.prompt_tokens;
     if (usage?.completion_tokens !== void 0) this.outputTokens = usage.completion_tokens;
@@ -11071,7 +11114,14 @@ function mapOpenAIFinish(reason) {
       return "end_turn";
   }
 }
-function buildOpenAIBody(request) {
+function applyReasoningRequest(body, effort, providerName) {
+  if (providerName === "openai") {
+    body.reasoning_effort = effort;
+    return;
+  }
+  body.reasoning = { effort };
+}
+function buildOpenAIBody(request, providerName) {
   const messages = [];
   const systemText = openAISystemText(request.system);
   if (systemText.length > 0) {
@@ -11090,6 +11140,8 @@ function buildOpenAIBody(request) {
   };
   if (request.maxTokens !== void 0) body.max_tokens = request.maxTokens;
   if (request.temperature !== void 0) body.temperature = request.temperature;
+  if (request.reasoning?.effort !== void 0)
+    applyReasoningRequest(body, request.reasoning.effort, providerName);
   if (request.tools !== void 0 && request.tools.length > 0) {
     body.tools = request.tools.map((tool) => ({
       type: "function",
@@ -11923,7 +11975,12 @@ function buildLoopInputs(options, runId, userText) {
   return {
     agentId: options.agentId,
     runId,
-    model: { id: effectiveModelId },
+    // issue #47: carry ModelSelection.params (the reasoning `thinking` param) into the loop so the
+    // request can forward reasoning. The id is stripped/normalized above; params pass through as-is.
+    model: {
+      id: effectiveModelId,
+      ...options.model?.params !== void 0 ? { params: options.model.params } : {}
+    },
     userMessage: userText,
     llm,
     mcp: buildMcpMap(options),