tinker-agent 1.4.0 → 1.5.1

package/src/cli/tui-runner.tsx

@@ -41,6 +41,9 @@ import { resolveSessionProfileName, type ModelProfile } from "./model-profiles";
 import { loadSkillCatalog } from "../skills/skill-loader";
 import { loadProjectSlashCommands } from "../tui/project-slash-commands";
 import { createWorkspaceFileLister } from "../tui/workspace-file-search";
+import { clipboardWriterForEnvironment } from "../tui/clipboard";
+import { initializeTuiMemory } from "./tui-memory";
+import { prepareShikiHighlighter } from "../tui/shiki-highlighter";
 
 export type RunTuiOptions = {
   readonly publicConfig: ResolvedPublicConfig;
@@ -49,10 +52,18 @@ export type RunTuiOptions = {
 };
 
 export async function runTui(options: RunTuiOptions): Promise<void> {
+  const shikiPreparation = prepareShikiHighlighter();
   const profiles =
     options.publicConfig.mode === "profile" ? options.publicConfig.profiles : undefined;
   const config = options.initialRunnerConfig;
   const workspaceRoot = await realpath(config.workspaceRoot);
+  const memory = await initializeTuiMemory({
+    config:
+      options.publicConfig.mode === "profile" ? options.publicConfig.memory : undefined,
+    env: options.env,
+  });
+  const memoryCoordinator = memory.coordinator;
+  const memoryNotice = memory.notice;
   let controller: DefaultTuiSessionController | undefined;
   let instance: ReturnType<typeof render> | undefined;
   let disposeReason: SessionDisposeReason = { type: "tui_exit" };
@@ -93,6 +104,15 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
         presentationSinks: [sink],
         webFetchRefiner: createWebFetchRefiner(sessionConfig, options.env),
         toolingConfig: options.publicConfig.tooling,
+        ...(memoryCoordinator === undefined
+          ? {}
+          : {
+              memorySearch: memoryCoordinator.createSearchToolExecutor({
+                workspaceRoot,
+                sessionId,
+              }),
+              completedTurnHook: memoryCoordinator,
+            }),
       };
       if (mode === "resume") {
         return createRuntimeSession({
@@ -238,6 +258,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
       createFreshSession,
     );
 
+    await shikiPreparation;
     instance = render(
       <App
         sessionController={controller}
@@ -255,10 +276,19 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
           timeoutMs: options.publicConfig.tooling.grepTimeoutMs,
           maxBufferBytes: options.publicConfig.tooling.grepMaxBufferBytes,
         })}
+        writeClipboard={clipboardWriterForEnvironment(options.env)}
         onQuit={() => {
           quitRequested = true;
         }}
+        initialNotice={memoryNotice}
+        memoryDisabledNotice={memoryNotice}
+        listStoredMemories={
+          memoryCoordinator === undefined
+            ? undefined
+            : () => memoryCoordinator.listStoredMemories()
+        }
       />,
+      { incrementalRendering: true },
     );
     await instance.waitUntilExit();
   } catch (error) {
@@ -267,6 +297,7 @@ export async function runTui(options: RunTuiOptions): Promise<void> {
   } finally {
     instance?.unmount();
     restoreStdin();
+    memoryCoordinator?.dispose();
     if (controller !== undefined) {
       try {
         await controller.dispose(disposeReason);

package/src/context/context-policy.ts

@@ -2,7 +2,7 @@ export const swapOnlyPolicyV1 = Object.freeze({
   version: "swap-only-v1",
   minimumObservationBytes: 8 * 1_024,
   protectedRecentTurnCount: 8,
-  targetInputRatio: 0.6,
+  targetInputRatio: 0.3,
 } as const);
 
 export type SwapOnlyPolicyV1 = typeof swapOnlyPolicyV1;
@@ -10,7 +10,7 @@ export type SwapOnlyPolicyV1 = typeof swapOnlyPolicyV1;
 export const recallFirstRetirementPolicyV1 = Object.freeze({
   version: "recall-first-retirement-v1",
   protectedRecentTurnCount: 8,
-  targetInputRatio: 0.6,
+  targetInputRatio: 0.3,
 } as const);
 
 export type RecallFirstRetirementPolicyV1 = typeof recallFirstRetirementPolicyV1;

package/src/events/stdout-event-printer.ts

@@ -204,6 +204,7 @@ function formatToolRawResult(call: ToolCall, raw: ToolRawResult): string[] {
     case "web_search":
     case "web_fetch":
     case "recall":
+    case "memory_search":
     case "mcp":
     case "generic":
       return [];

package/src/memory/contracts.ts

@@ -0,0 +1,148 @@
+import type { SessionId, TurnId } from "../ids/runtime-id";
+
+export const MEMORY_SEARCH_TOOL_NAME = "MemorySearch" as const;
+export const MEMORY_SCHEMA_VERSION = 1 as const;
+export const MAX_MEMORIES_PER_TURN = 4;
+export const MAX_MEMORY_TEXT_BYTES = 512;
+export const MAX_MEMORY_QUERY_BYTES = 1_024;
+export const MEMORY_SEARCH_LIMIT = 5;
+
+export type MemoryEmbeddingKind = "openai-compatible";
+
+export type MemoryEmbeddingConfig = {
+  readonly name: string;
+  readonly kind: MemoryEmbeddingKind;
+  readonly model: string;
+  readonly apiBase: string;
+  readonly apiKey: string;
+  readonly dimensions: number;
+};
+
+export type MemoryEmbeddingIdentity = Pick<
+  MemoryEmbeddingConfig,
+  "name" | "kind" | "model" | "dimensions"
+>;
+
+export type MemoryPaths = {
+  readonly directory: string;
+  readonly database: string;
+  readonly log: string;
+  readonly extractedLog: string;
+};
+
+export type MemoryWriteCandidate = {
+  readonly text: string;
+  readonly embedding: Float32Array;
+};
+
+export type MemoryWriteBatch = {
+  readonly workspaceRoot: string;
+  readonly sessionId: SessionId;
+  readonly turnId: TurnId;
+  readonly candidates: readonly MemoryWriteCandidate[];
+};
+
+export type MemoryWriteResult = {
+  readonly written: number;
+  readonly duplicate: number;
+  readonly inserted: readonly MemoryInsertedRecord[];
+};
+
+export type MemoryInsertedRecord = {
+  readonly memoryId: string;
+  readonly text: string;
+  readonly createdAt: string;
+};
+
+export type MemorySearchMatch = {
+  readonly memoryId: string;
+  readonly text: string;
+  readonly score: number;
+  readonly sourceWorkspace: string;
+  readonly createdAt: string;
+};
+
+export type StoredMemorySummary = {
+  readonly memoryId: string;
+  readonly text: string;
+  readonly sourceWorkspace: string;
+  readonly createdAt: string;
+};
+
+export type MemoryExtractionRejectedCounts = {
+  readonly duplicate: number;
+  readonly secret: number;
+  readonly invalid: number;
+  readonly embedding: number;
+};
+
+export type MemoryExtractionDiagnostic = {
+  readonly at: string;
+  readonly kind: "extraction";
+  readonly outcome: "ok" | "failed" | "skipped";
+  readonly reason: string | null;
+  readonly workspace: string;
+  readonly turnId: string;
+  readonly inputTokens: number;
+  readonly returned: number;
+  readonly written: number;
+  readonly rejected: MemoryExtractionRejectedCounts;
+  readonly ms: number;
+};
+
+export type MemorySearchDiagnostic = {
+  readonly at: string;
+  readonly kind: "search";
+  readonly outcome: "ok" | "failed" | "skipped";
+  readonly reason: string | null;
+  readonly workspace: string;
+  readonly sessionId: string;
+  readonly queryBytes: number;
+  readonly returned: number;
+  readonly scores: readonly number[];
+  readonly ms: number;
+};
+
+export type MemoryInitDiagnostic = {
+  readonly at: string;
+  readonly kind: "init";
+  readonly outcome: "failed";
+  readonly reason: string;
+};
+
+export type MemoryDiagnostic =
+  | MemoryExtractionDiagnostic
+  | MemorySearchDiagnostic
+  | MemoryInitDiagnostic;
+
+export class MemoryError extends Error {
+  constructor(
+    readonly code: string,
+    message: string,
+    options?: ErrorOptions,
+  ) {
+    super(message, options);
+    this.name = "MemoryError";
+  }
+}
+
+export function memoryErrorCode(error: unknown, fallback: string): string {
+  return error instanceof MemoryError ? error.code : fallback;
+}
+
+export function boundedMemoryError(error: unknown): string {
+  const raw = error instanceof Error ? error.message : String(error);
+  const singleLine = raw.replaceAll(/\s+/g, " ").trim() || "unknown memory error";
+  return truncateUtf8(singleLine, 400);
+}
+
+function truncateUtf8(value: string, maxBytes: number): string {
+  if (Buffer.byteLength(value, "utf8") <= maxBytes) {
+    return value;
+  }
+  let end = Math.min(value.length, maxBytes);
+  while (end > 0 && Buffer.byteLength(`${value.slice(0, end)}…`, "utf8") > maxBytes) {
+    end -= 1;
+  }
+  return `${value.slice(0, end)}…`;
+}

package/src/memory/embedding-client.ts

@@ -0,0 +1,105 @@
+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[])[]);
+  }
+}