tinker-agent 2.11.0 → 2.13.0

package/src/tui/app.tsx

@@ -84,7 +84,9 @@ export type AppProps = {
   writeClipboard?: (markdown: string) => Promise<void>;
   onQuit?: () => void;
   initialNotice?: string;
-  listStoredMemories?: () => readonly StoredMemorySummary[];
+  listStoredMemories?: () =>
+    | readonly StoredMemorySummary[]
+    | Promise<readonly StoredMemorySummary[]>;
   memoryDisabledNotice?: string;
 };
 
@@ -418,13 +420,13 @@ export function App(props: AppProps) {
     restoreStaticViewport();
   };
 
-  const openMemoryView = () => {
+  const openMemoryView = async () => {
     if (props.listStoredMemories === undefined) {
       setNotice(props.memoryDisabledNotice ?? "memory disabled: not configured");
       return;
     }
     try {
-      const snapshot = props.listStoredMemories();
+      const snapshot = await props.listStoredMemories();
       setNotice(undefined);
       setMemoryView(snapshot);
     } catch (error) {
@@ -646,7 +648,7 @@ export function App(props: AppProps) {
           return true;
         }
         if (command.type === "memory") {
-          openMemoryView();
+          void openMemoryView();
           return true;
         }
         if (command.type === "copy") {

package/src/tui/event-store.ts

@@ -835,7 +835,7 @@ function toolCallSummary(input: { name: string; args: unknown }): string {
     return `WebSearch ${toolQuery(input.args) ?? ""}`.trim();
   }
   if (input.name === "MemorySearch") {
-    return `MemorySearch ${memorySearchDetail(input.args)}`.trim();
+    return `MemorySearch ${toolPattern(input.args) ?? memorySearchDetail(input.args)}`.trim();
   }
   if (input.name === "MemoryCreate") {
     return "MemoryCreate";
@@ -974,6 +974,8 @@ function toolRawResultSummary(name: string, args: unknown, raw: ToolRawResult):
       if (!raw.ok) {
         return base;
       }
+      if ("format" in raw)
+        return `${base} -> ${raw.returnedResults} matching lines in ${raw.files.length} files`;
       return `${base} -> ${raw.matches.length} derived memor${raw.matches.length === 1 ? "y" : "ies"}`;
     case "memory_get":
       if (!raw.ok) {

package/src/cli/tui-memory.ts

@@ -1,69 +0,0 @@
-import {
-  boundedMemoryError,
-  memoryErrorCode,
-  type MemoryPaths,
-} from "../memory/contracts";
-import { MemoryCoordinator } from "../memory/memory-coordinator";
-import { MemoryLog } from "../memory/memory-log";
-import { resolveMemoryPaths } from "../memory/memory-store";
-import type { ResolvedMemoryConfig } from "./config";
-import { createModelClient } from "./runner-dependencies";
-
-export type TuiMemoryInitialization = {
-  readonly coordinator?: MemoryCoordinator;
-  readonly notice?: string;
-};
-
-export async function initializeTuiMemory(input: {
-  readonly config?: ResolvedMemoryConfig;
-  readonly env: NodeJS.ProcessEnv;
-  readonly paths?: MemoryPaths;
-  readonly createCoordinator?: typeof MemoryCoordinator.create;
-}): Promise<TuiMemoryInitialization> {
-  if (input.config === undefined) {
-    return Object.freeze({});
-  }
-
-  const paths = input.paths ?? resolveMemoryPaths();
-  const log = new MemoryLog(paths.log);
-  try {
-    const memoryConfig = input.config;
-    const coordinator = await (input.createCoordinator ?? MemoryCoordinator.create)({
-      paths,
-      embedding: memoryConfig.embedding,
-      extractionContextBudget: memoryConfig.contextBudget,
-      createExtractionClient: () => {
-        const profile = memoryConfig.profile;
-        return createModelClient(
-          {
-            modelName: profile.model,
-            api: profile.api,
-            apiKey: profile.apiKey,
-            apiBase: profile.apiBase,
-            ...(profile.reasoning === undefined
-              ? {}
-              : { reasoning: profile.reasoning }),
-            includeReasoningContent: profile.includeReasoningContent,
-            stream: profile.stream,
-            contextBudget: memoryConfig.contextBudget,
-            inputModalities: profile.inputModalities,
-            toolResultModalities: profile.toolResultModalities,
-          },
-          input.env,
-        );
-      },
-    });
-    return Object.freeze({ coordinator });
-  } catch (error) {
-    const reason = memoryErrorCode(error, "memory_init_failed");
-    await log.append({
-      at: new Date().toISOString(),
-      kind: "init",
-      outcome: "failed",
-      reason,
-    });
-    return Object.freeze({
-      notice: `memory disabled: ${boundedMemoryError(error)}`,
-    });
-  }
-}

package/src/memory/embedding-client.ts

@@ -1,105 +0,0 @@
-import OpenAI from "openai";
-import type { MemoryEmbeddingConfig } from "./contracts";
-import { MemoryError } from "./contracts";
-
-const EMBEDDING_TIMEOUT_MS = 60_000;
-const EMBEDDING_MAX_RETRIES = 2;
-
-export interface MemoryEmbeddingClient {
-  embed(
-    inputs: readonly string[],
-    signal: AbortSignal,
-  ): Promise<readonly (readonly number[])[]>;
-}
-
-export class OpenAICompatibleEmbeddingClient implements MemoryEmbeddingClient {
-  private readonly client: OpenAI;
-
-  constructor(
-    private readonly config: MemoryEmbeddingConfig,
-    options: { readonly fetch?: typeof fetch } = {},
-  ) {
-    this.client = new OpenAI({
-      apiKey: config.apiKey,
-      baseURL: config.apiBase,
-      timeout: EMBEDDING_TIMEOUT_MS,
-      maxRetries: EMBEDDING_MAX_RETRIES,
-      ...(options.fetch === undefined ? {} : { fetch: options.fetch }),
-    });
-  }
-
-  async embed(
-    inputs: readonly string[],
-    signal: AbortSignal,
-  ): Promise<readonly (readonly number[])[]> {
-    if (inputs.length === 0) {
-      throw new MemoryError(
-        "memory_embedding_input_invalid",
-        "Embedding input must not be empty.",
-      );
-    }
-    signal.throwIfAborted();
-
-    let response;
-    try {
-      response = await this.client.embeddings.create(
-        {
-          model: this.config.model,
-          input: [...inputs],
-          encoding_format: "float",
-        },
-        { signal },
-      );
-    } catch (error) {
-      if (signal.aborted) {
-        throw error;
-      }
-      throw new MemoryError(
-        "memory_embedding_request_failed",
-        "Embedding provider request failed.",
-        { cause: error },
-      );
-    }
-    signal.throwIfAborted();
-
-    if (!Array.isArray(response.data)) {
-      throw new MemoryError(
-        "memory_embedding_response_invalid",
-        "Embedding response did not contain a data array.",
-      );
-    }
-    if (response.data.length !== inputs.length) {
-      throw new MemoryError(
-        "memory_embedding_response_invalid",
-        `Embedding response returned ${response.data.length} vectors for ${inputs.length} inputs.`,
-      );
-    }
-
-    const vectors: Array<readonly number[] | undefined> = Array.from({
-      length: inputs.length,
-    });
-    for (const item of response.data) {
-      if (
-        !Number.isSafeInteger(item.index) ||
-        item.index < 0 ||
-        item.index >= inputs.length ||
-        vectors[item.index] !== undefined ||
-        !Array.isArray(item.embedding) ||
-        item.embedding.some((value) => typeof value !== "number")
-      ) {
-        throw new MemoryError(
-          "memory_embedding_response_invalid",
-          "Embedding response indices or vectors are invalid.",
-        );
-      }
-      vectors[item.index] = Object.freeze([...item.embedding]);
-    }
-    if (vectors.some((vector) => vector === undefined)) {
-      throw new MemoryError(
-        "memory_embedding_response_invalid",
-        "Embedding response did not map every input index.",
-      );
-    }
-    return Object.freeze(vectors as readonly (readonly number[])[]);
-  }
-}