tinker-agent 2.2.0 → 2.4.0

package/src/model/fake-model-client.ts

@@ -86,6 +86,7 @@ export class FakeModelClient implements ModelClient {
         requestMaxOutputTokens: this.options.contextBudget.requestMaxOutputTokens,
         inputModalities: this.inputModalities,
         toolResultModalities: this.toolResultModalities,
+        responseFormat: input.responseFormat?.type ?? null,
       }),
     );
     const prepared: PreparedModelRequest = Object.freeze({
@@ -96,6 +97,9 @@ export class FakeModelClient implements ModelClient {
         tools: Object.freeze([...input.tools]),
         maxTokens: this.options.contextBudget.requestMaxOutputTokens,
         ...(reasoningEffort === undefined ? {} : { reasoningEffort }),
+        ...(input.responseFormat === undefined
+          ? {}
+          : { responseFormat: input.responseFormat }),
       }),
       promptSegments: Object.freeze([...toolSegments, ...messageSegments]),
       requestConfigHash,
@@ -111,6 +115,9 @@ export class FakeModelClient implements ModelClient {
     this.preparedInputs.set(prepared, {
       messages: [...input.messages],
       tools: [...input.tools],
+      ...(input.responseFormat === undefined
+        ? {}
+        : { responseFormat: input.responseFormat }),
     });
     return prepared;
   }

package/src/model/model-client.ts

@@ -103,9 +103,20 @@ export type ModelRequestOptions = {
   };
 };
 
+/**
+ * Provider-enforced structured output for a single request. Distinct from
+ * prompt-level instructions: the provider constrains the decoded response to
+ * be a valid JSON object, so callers still validate shape but no longer fight
+ * markdown fences or surrounding prose.
+ */
+export type ModelResponseFormat = {
+  readonly type: "json_object";
+};
+
 export type ModelRequestInput = {
   messages: AgentMessage[];
   tools: ToolDefinition[];
+  responseFormat?: ModelResponseFormat;
 };
 
 export type PreparedPromptSegmentKind =

package/src/model/openai-chat-model-client.ts

@@ -107,6 +107,9 @@ export class OpenAIChatModelClient implements ModelClient {
       messages,
       ...(tools === undefined ? {} : { tools, tool_choice: "auto" as const }),
       ...(reasoningEffort === undefined ? {} : { reasoning_effort: reasoningEffort }),
+      ...(input.responseFormat === undefined
+        ? {}
+        : { response_format: { type: input.responseFormat.type } }),
       max_completion_tokens: this.options.contextBudget.requestMaxOutputTokens,
       ...(this.stream
         ? {
@@ -147,7 +150,10 @@ export class OpenAIChatModelClient implements ModelClient {
         stream: this.stream,
         inputModalities: this.inputModalities,
         toolResultModalities: this.toolResultModalities,
-        requestPolicy: { toolChoice: "auto" },
+        requestPolicy: {
+          toolChoice: "auto",
+          responseFormat: input.responseFormat?.type ?? null,
+        },
         imagePolicy: {
           version: IMAGE_INPUT_POLICY_VERSION,
           ...IMAGE_INPUT_POLICY,

package/src/model/openai-responses-model-client.ts

@@ -111,6 +111,9 @@ export class OpenAIResponsesModelClient implements ModelClient {
         : { reasoning: { effort: reasoningEffort } }),
       max_output_tokens: this.options.contextBudget.requestMaxOutputTokens,
       store: false as const,
+      ...(input.responseFormat === undefined
+        ? {}
+        : { text: { format: { type: input.responseFormat.type } } }),
       ...(this.stream ? { stream: true as const } : {}),
     });
     const toolSegments = (tools ?? []).map(
@@ -148,7 +151,11 @@ export class OpenAIResponsesModelClient implements ModelClient {
         stream: this.stream,
         inputModalities: this.inputModalities,
         toolResultModalities: this.toolResultModalities,
-        requestPolicy: { store: false, toolChoice: "auto" },
+        requestPolicy: {
+          store: false,
+          toolChoice: "auto",
+          responseFormat: input.responseFormat?.type ?? null,
+        },
         imagePolicy: {
           version: IMAGE_INPUT_POLICY_VERSION,
           ...IMAGE_INPUT_POLICY,

package/src/observation/observation-builder.ts

@@ -6,6 +6,7 @@ import {
 } from "../agent/tool-result-content";
 import type {
   BashRawResult,
+  ContextMaintenanceRawResult,
   DeleteFileRawResult,
   EditFileRawResult,
   GenericToolRawResult,
@@ -48,6 +49,8 @@ export class ObservationBuilder {
         return renderViewImageObservation(input.raw);
       case "recall":
         return textObservation(renderRecallObservation(input.raw));
+      case "context_maintenance":
+        return textObservation(renderContextMaintenanceObservation(input.raw));
       case "memory_search":
         return textObservation(renderMemorySearchObservation(input.raw));
       case "memory_get":
@@ -117,6 +120,39 @@ function renderWaitObservation(raw: WaitRawResult): string {
     : `Wait failed: ${raw.error}`;
 }
 
+function renderContextMaintenanceObservation(raw: ContextMaintenanceRawResult): string {
+  if (!raw.ok) {
+    if (raw.operation === "swap" && raw.rejected.length > 0) {
+      return JSON.stringify({ ok: false, rejected: raw.rejected });
+    }
+    return JSON.stringify({ ok: false, error: raw.error });
+  }
+  switch (raw.operation) {
+    case "status":
+      return JSON.stringify({
+        ok: true,
+        usedInputTokens: raw.usedInputTokens,
+        inputBudgetTokens: raw.inputBudgetTokens,
+        pressure: raw.pressure,
+        triggerTokens: raw.triggerTokens,
+        source: raw.source,
+      });
+    case "candidates":
+      return JSON.stringify({
+        ok: true,
+        total: raw.total,
+        candidates: raw.candidates,
+      });
+    case "swap":
+      return JSON.stringify({
+        ok: true,
+        scheduled: raw.scheduled,
+        rejected: raw.rejected,
+        note: raw.note,
+      });
+  }
+}
+
 function assertNever(value: never): never {
   throw new Error(`Unhandled tool raw result: ${JSON.stringify(value)}`);
 }

package/src/session/resume-projection.ts

@@ -1,4 +1,3 @@
-import path from "node:path";
 import { realpath } from "node:fs/promises";
 import { Database } from "bun:sqlite";
 import type { ToolCall } from "../agent/types";
@@ -24,7 +23,11 @@ import {
 } from "../tui/tui-projection-policy";
 import { SessionError } from "./session-errors";
 import { verifySessionSchema } from "./session-schema";
-import { decodeStoredToolCalls, decodeStoredToolRawResult } from "./session-store";
+import {
+  decodeStoredToolCalls,
+  decodeStoredToolRawResult,
+  resolveSessionDatabasePath,
+} from "./session-store";
 import {
   MAX_TIMELINE_PROMPT_CODE_POINTS,
   projectUserMessage,
@@ -46,17 +49,16 @@ export class ResumeProjectionReader {
     sessionId: SessionId;
     modelName: string;
     policy?: TuiProjectionPolicy;
+    homeRoot?: string;
   }): Promise<TuiProjectionState> {
     const policy = validateTuiProjectionPolicy(
       input.policy ?? defaultTuiProjectionPolicy,
     );
     const workspaceRoot = await realpath(input.workspaceRoot);
-    const databasePath = path.join(
+    const databasePath = await resolveSessionDatabasePath(
       workspaceRoot,
-      ".tinker",
-      "sessions",
       input.sessionId,
-      "session.sqlite",
+      input.homeRoot,
     );
     const database = new Database(databasePath, {
       readonly: true,

package/src/session/session-catalog.ts

@@ -6,6 +6,7 @@ import { SessionError } from "./session-errors";
 import { inspectSessionLock } from "./session-lock";
 import { SessionStore } from "./session-store";
 import { verifyReadableSessionSchema } from "./session-schema";
+import { canonicalHomeRoot, workspaceStorageRoot } from "./workspace-storage";
 
 export type SessionSummary = {
   sessionId: SessionId;
@@ -28,9 +29,22 @@ export type SessionSummary = {
 
 export class SessionCatalog {
   private readonly workspaceRootPromise: Promise<string>;
+  private readonly sessionsRootPromise: Promise<string>;
 
-  constructor(private readonly input: { workspaceRoot: string; limit?: number }) {
+  constructor(
+    private readonly input: {
+      workspaceRoot: string;
+      limit?: number;
+      homeRoot?: string;
+    },
+  ) {
     this.workspaceRootPromise = realpath(input.workspaceRoot);
+    this.sessionsRootPromise = this.workspaceRootPromise.then(async (workspaceRoot) =>
+      path.join(
+        workspaceStorageRoot(workspaceRoot, await canonicalHomeRoot(input.homeRoot)),
+        "sessions",
+      ),
+    );
   }
 
   async list(currentSessionId?: SessionId): Promise<readonly SessionSummary[]> {
@@ -44,7 +58,7 @@ export class SessionCatalog {
 
   private async scan(currentSessionId?: SessionId): Promise<SessionSummary[]> {
     const workspaceRoot = await this.workspaceRootPromise;
-    const sessionsRoot = path.join(workspaceRoot, ".tinker", "sessions");
+    const sessionsRoot = await this.sessionsRootPromise;
     let entries;
     try {
       entries = await readdir(sessionsRoot, { withFileTypes: true });
@@ -87,7 +101,7 @@ export class SessionCatalog {
     currentSessionId?: SessionId,
   ): Promise<SessionSummary> {
     const workspaceRoot = await this.workspaceRootPromise;
-    const directory = path.join(workspaceRoot, ".tinker", "sessions", sessionId);
+    const directory = path.join(await this.sessionsRootPromise, sessionId);
     return readSummary(directory, sessionId, workspaceRoot, currentSessionId);
   }
 
@@ -105,6 +119,7 @@ export class SessionCatalog {
       workspaceRoot,
       sessionId,
       allowIncomplete: true,
+      ...(this.input.homeRoot === undefined ? {} : { homeRoot: this.input.homeRoot }),
     });
     try {
       await store.deleteFromDisk();

package/src/session/session-last-response-reader.ts

@@ -4,22 +4,26 @@ import { contentHash } from "../context/protocol-frame";
 import type { SessionId } from "../ids/runtime-id";
 import { SessionError, sessionOpenError, sessionReadError } from "./session-errors";
 import { verifySessionSchema } from "./session-schema";
-import { decodeStoredToolCalls, sessionDatabasePath } from "./session-store";
+import { decodeStoredToolCalls, resolveSessionDatabasePath } from "./session-store";
 
 const OPERATION = "read_last_assistant_response";
 
 export async function readLastAssistantResponse(input: {
   workspaceRoot: string;
   sessionId: SessionId;
+  homeRoot?: string;
 }): Promise<string | undefined> {
   const workspaceRoot = await realpath(input.workspaceRoot);
   let database: Database;
   try {
-    database = new Database(sessionDatabasePath(workspaceRoot, input.sessionId), {
-      readonly: true,
-      strict: true,
-      safeIntegers: true,
-    });
+    database = new Database(
+      await resolveSessionDatabasePath(workspaceRoot, input.sessionId, input.homeRoot),
+      {
+        readonly: true,
+        strict: true,
+        safeIntegers: true,
+      },
+    );
   } catch (error) {
     throw sessionOpenError(OPERATION, input.sessionId, error);
   }