@theokit/sdk-tools 0.9.1 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.11.0
+
+### Minor Changes
+
+- SE38 (#119) — `createTodolistTool()` is now session-aware: it scopes its items by the
+  run's `ctx.threadId`, so one tool object served to many sessions from a single process
+  (the multi-tenant server shape) no longer leaks one session's list into another. When no
+  `threadId` is present (single-session CLI usage) every call shares one default session, so
+  existing behavior is unchanged. `handler` accepts an optional 2nd `ctx` argument and
+  `getItems(threadId?)` is session-scoped — both additive/back-compatible.
+
+## 0.10.0
+
+### Minor Changes
+
+- 2606c98: SE37 — Reasoning ergonomics. Ships `ReasoningTools.create()` (`think`/`analyze` scratchpad tools, from `@theokit/sdk` core, re-exported by `@theokit/sdk-tools`) and a lightweight `AgentOptions.reasoning?: boolean` flag. When `reasoning: true`, the agent gets a chain-of-thought preamble prepended to its system prompt AND the reasoning tools auto-attached, turning a non-reasoning model into a reason→act→observe loop using the SAME model (reuses the existing tool loop; no new runtime). Inert (with a one-time warn) when a native reasoning model is configured (`model.params: [{ id: "thinking" }]`) — native reasoning wins, no double-reasoning. Default off; byte-identical behaviour when unset. Validated REAL on OpenRouter: `reasoning: true` drove the `think` tool and answered the "9.11 vs 9.9" trap correctly (9.9).
+
 ## 0.9.1
 
 ### Patch Changes

package/dist/index.cjs

@@ -1435,6 +1435,37 @@ function evaluateReadBeforeWrite(tracker, path, currentMtimeMs) {
   if (recorded !== currentMtimeMs) return "stale";
   return "ok";
 }
+var ReasoningTools = class {
+  constructor() {
+  }
+  /** Build the tools. Pass `{ analyze: false }` for `think` only. */
+  static create(opts) {
+    const think = sdk.Tool.create({
+      name: "think",
+      description: "Use this as a scratchpad to think step by step BEFORE answering or acting. Write out your reasoning for one step. Nothing else happens \u2014 it is only your private reasoning space. Call it as many times as you need before the final answer.",
+      inputSchema: zod.z.object({
+        thought: zod.z.string().min(1, "think: `thought` must be a non-empty string.")
+      }),
+      handler: ({ thought }) => thought
+    });
+    if (opts?.analyze === false) return [think];
+    const analyze = sdk.Tool.create({
+      name: "analyze",
+      description: "Analyze the result of a previous step or tool call. State what you looked at, your analysis, and whether to `continue` reasoning, `validate` (double-check) your work, or give the `final_answer`. Use this to catch your own mistakes before answering.",
+      inputSchema: zod.z.object({
+        title: zod.z.string().optional(),
+        result: zod.z.string().min(1, "analyze: `result` must describe what you are analyzing."),
+        analysis: zod.z.string().min(1, "analyze: `analysis` must contain your reasoning."),
+        next_action: zod.z.enum(["continue", "validate", "final_answer"])
+      }),
+      handler: ({ title, result, analysis, next_action }) => `${title ? `# ${title}
+` : ""}Result: ${result}
+Analysis: ${analysis}
+Next: ${next_action}`
+    });
+    return [think, analyze];
+  }
+};
 var DEFAULT_TIMEOUT_MS2 = 12e4;
 var DEFAULT_MAX_STDOUT_BYTES2 = 10 * 1024 * 1024;
 function createRunVitestTool(opts) {
@@ -1772,7 +1803,7 @@ function requireId(input) {
   if (!("id" in input) || !input.id) return null;
   return input.id;
 }
-function createTodolistTool() {
+function makeSessionOps() {
   const items = [];
   let nextId = 1;
   function genId() {
@@ -1841,6 +1872,26 @@ ${done}/${items.length} done | ${inProg} in progress | ${pending} pending`);
     list: () => listResult({}),
     clear_completed: handleClearCompleted
   };
+  return {
+    handle: (input) => {
+      const action = actions[input.action];
+      if (!action) return fail({ error: "invalid_action" });
+      return action(input);
+    },
+    getItems: () => [...items]
+  };
+}
+function createTodolistTool() {
+  const sessions = /* @__PURE__ */ new Map();
+  function ops(threadId) {
+    const key = threadId ?? "__default__";
+    let session = sessions.get(key);
+    if (session === void 0) {
+      session = makeSessionOps();
+      sessions.set(key, session);
+    }
+    return session;
+  }
   return {
     name: "todolist",
     description: "Create and maintain a structured task list for the current session \u2014 tracks progress and keeps a multi-step plan visible across turns. Use it proactively when the work has 3+ steps or the user gave multiple tasks; skip it for a single trivial step. Keep exactly ONE item 'in_progress' at a time, and mark 'complete' only after the work is actually done. Actions: 'add' (create with title), 'in_progress' (mark started by id), 'complete' (mark done by id), 'remove' (delete by id), 'list' (show all), 'clear_completed' (remove done items). Returns { ok, items, items_summary } (items = structured array; items_summary = formatted text).",
@@ -1863,12 +1914,8 @@ ${done}/${items.length} done | ${inProg} in progress | ${pending} pending`);
       },
       required: ["action"]
     },
-    handler: (input) => {
-      const action = actions[input.action];
-      if (!action) return fail({ error: "invalid_action" });
-      return action(input);
-    },
-    getItems: () => [...items]
+    handler: (input, ctx) => ops(ctx?.threadId).handle(input),
+    getItems: (threadId) => ops(threadId).getItems()
   };
 }
 function truncateOutput(output, opts) {
@@ -2197,6 +2244,7 @@ async function isBinaryFile(absolutePath) {
 exports.CatastrophicCommandError = CatastrophicCommandError;
 exports.DEFAULT_TOOL_GUIDANCE = DEFAULT_TOOL_GUIDANCE;
 exports.ReadTracker = ReadTracker;
+exports.ReasoningTools = ReasoningTools;
 exports.RedirectBlockedError = RedirectBlockedError;
 exports.SsrfBlockedError = SsrfBlockedError;
 exports.buildEnvContext = buildEnvContext;