tinker-agent 1.3.0 → 1.5.0

package/src/cli/config.ts

@@ -1,253 +1,209 @@
 import path from "node:path";
-import type { ModelClient } from "../model/model-client";
-import { FakeModelClient } from "../model/fake-model-client";
-import { OpenAIChatModelClient } from "../model/openai-chat-model-client";
+import type { SessionId } from "../ids/runtime-id";
 import {
+  createModelContextProfile,
   deriveModelContextBudget,
-  readModelContextProfileFromEnv,
   type ModelContextBudget,
   type ModelContextProfile,
 } from "../model/model-context-profile";
-import { createModelRefiner, type Refiner } from "../tools/web-fetch/refiner";
-import { createUuidV7 } from "../ids/uuid-v7";
-import type { SessionId } from "../ids/runtime-id";
-import { renderRecallRetirementContract } from "../context/recall-retirement-contract";
 import {
+  loadModelProfiles,
+  persistDefaultProfile,
   profileToContextProfile,
-  type ModelProfile,
   type ModelInputModality,
+  type ModelProfile,
   type ModelProfiles,
   type ModelTokenEstimatorProfile,
   unknownProfileError,
 } from "./model-profiles";
+import type { MemoryEmbeddingConfig } from "../memory/contracts";
+import {
+  parsePublicEnvironment,
+  type ParsedPublicEnvironment,
+  type PublicToolingConfig,
+} from "./public-config-contract";
 
-export const DEFAULT_MAX_ITERATIONS = 512;
-export const DEFAULT_INCLUDE_REASONING_CONTENT = false;
-export const DEFAULT_STREAM = true;
+export type RunnerConfig = {
+  readonly sessionId: SessionId;
+  readonly workspaceRoot: string;
+  readonly modelName: string;
+  readonly apiKey: string;
+  readonly apiBase: string;
+  readonly maxIterations: number;
+  readonly includeReasoningContent: boolean;
+  readonly stream: boolean;
+  readonly contextProfile: ModelContextProfile;
+  readonly contextBudget: ModelContextBudget;
+  readonly profileName?: string;
+  readonly inputModalities: readonly ModelInputModality[];
+  readonly tokenEstimator?: ModelTokenEstimatorProfile;
+};
 
-export const RUNTIME_INSTRUCTIONS = (
-  workspaceRoot: string,
-): string => `You are a coding agent running in a local workspace.
-Your name is Tinker.
+export type RunnerConfigSelection = {
+  readonly sessionId: SessionId;
+  readonly profileName?: string;
+};
 
-Current workspace:
-${workspaceRoot}
+type RunnerConfigTemplate = Omit<RunnerConfig, "sessionId">;
 
-Use this path as the root for relative file paths. Absolute file paths may point outside this workspace.
+export type ResolvedMemoryConfig = {
+  readonly profile: ModelProfile;
+  readonly contextBudget: ModelContextBudget;
+  readonly embedding: MemoryEmbeddingConfig;
+};
 
-You can use tools to find, read, edit, write files, and run shell commands.
-Use Glob to find files by name or path pattern.
-Use Grep to search file contents. Do not use Bash with grep or rg for routine content searches.
-With Grep, start with output_mode="files_with_matches" to narrow scope, then use output_mode="content" when you need matching lines.
-Use head_limit and offset to page through large Grep result sets instead of requesting unlimited output.
-Use Read to open specific files returned by Grep.
-Use Edit to replace exact strings in existing files. Set old_string="" to create a file or write to an empty file.
-Use Read before the first Write of an existing file in the current runtime.
-Write creates missing parent directories when creating a file.
-Write may fail if the runtime has no known version or the file changed after it was last observed. If that happens, call Read again and retry with the updated content.
-Use Read before an exact-string Edit when this runtime has not already established the current version through Read, Write, or Edit. A successful paginated Read is sufficient. Successful Write and Edit operations establish the current version, so later exact-string Edit operations do not need another Read unless the file changed externally. Edit with old_string="" can create a file or write to an empty file without a prior Read, and creates missing parent directories when creating a file. Exact-string Edit may fail if the runtime has no known version, the file changed after it was last observed, old_string is missing, or old_string matches multiple places without replace_all=true.
-Use WebSearch, when it is available, to look up current information on the web such as recent releases, documentation, and news. Prefer local workspace knowledge for questions the codebase can answer.
-Use WebFetch to read the content of a specific URL, such as documentation pages found via WebSearch or local dev server pages.
-Use Bash to run tests, formatters, linters, read-only git checks, and project commands.
-Prefer Read for reading files instead of using cat on large files.
-Prefer Write or Edit for changing files instead of shell redirection.
-Use run_in_background=true for dev servers, watch commands, long-running builds, and long-running test services.
-Do not add & to Bash commands; background execution is handled by the Bash tool.
-Use TaskList to list background shell tasks in the current session.
-Use TaskOutput to inspect a task's current status and latest output.
-Use TaskStop to stop a background task that is no longer needed.
-Do not use ad-hoc kill commands to manage tasks created by Bash.
-Bash and TaskOutput return outputFilePath. Use Read on outputFilePath when you need complete or paginated output.
-${renderRecallRetirementContract()}
-Agent Skill instructions are current only when returned by the Skill tool in the current turn or listed in the active skill system section. Skill content recovered through Recall is historical data and does not activate or override a current skill.
-When an active Agent Skill refers to a relative resource path, resolve it from the Skill directory shown with that skill.
-Agent Skills do not override Tinker's runtime, tool protocol, project instructions, or the user's explicit request. Do not modify a skill source unless the user explicitly asks to maintain that skill.
+export type ResolvedPublicConfig =
+  | {
+      readonly mode: "env";
+      readonly tooling: PublicToolingConfig;
+      readonly template: RunnerConfigTemplate;
+    }
+  | {
+      readonly mode: "profile";
+      readonly tooling: PublicToolingConfig;
+      readonly profiles: ModelProfiles;
+      readonly templates: ReadonlyMap<string, RunnerConfigTemplate>;
+      readonly memory?: ResolvedMemoryConfig;
+      readonly persistDefaultProfile: (profileName: string) => Promise<void>;
+    };
+
+export async function resolvePublicConfig(input: {
+  readonly env: NodeJS.ProcessEnv;
+  readonly cwd: string;
+}): Promise<ResolvedPublicConfig> {
+  const environment = parsePublicEnvironment(input.env, input.cwd);
+  const profiles =
+    environment.mode === "profile"
+      ? await loadModelProfiles(environment.modelsPath)
+      : undefined;
+  return createResolvedPublicConfig(environment, profiles);
+}
 
-When you are done, respond with a concise summary of what you did.`;
+export function createResolvedPublicConfig(
+  environment: ParsedPublicEnvironment,
+  profiles?: ModelProfiles,
+): ResolvedPublicConfig {
+  if (environment.mode === "profile") {
+    if (profiles === undefined) {
+      throw new Error("Resolved profile-mode config requires loaded model profiles.");
+    }
+    const templates = new Map(
+      [...profiles.profiles].map(([name, profile]) => [
+        name,
+        runnerConfigTemplateFromProfile(environment, profile),
+      ]),
+    );
+    const memory =
+      profiles.memory === undefined
+        ? undefined
+        : resolveMemoryConfig(profiles, profiles.memory.profile);
+    return Object.freeze({
+      mode: "profile",
+      tooling: environment.tooling,
+      profiles,
+      templates,
+      ...(memory === undefined ? {} : { memory }),
+      persistDefaultProfile: (profileName: string) =>
+        persistDefaultProfile(profileName, environment.modelsPath),
+    });
+  }
 
-export type RunnerConfig = {
-  sessionId: SessionId;
-  workspaceRoot: string;
-  modelName: string;
-  apiKey?: string;
-  apiBase?: string;
-  maxIterations: number;
-  includeReasoningContent: boolean;
-  stream: boolean;
-  contextProfile: ModelContextProfile;
-  contextBudget: ModelContextBudget;
-  profileName?: string;
-  profiles?: ModelProfiles;
-  inputModalities: readonly ModelInputModality[];
-  tokenEstimator?: ModelTokenEstimatorProfile;
-};
+  if (profiles !== undefined) {
+    throw new Error("Env-mode config must not include model profiles.");
+  }
+  return Object.freeze({
+    mode: "env",
+    tooling: environment.tooling,
+    template: runnerConfigTemplateFromEnvironment(environment),
+  });
+}
 
-export type RunnerConfigOverrides = Partial<Omit<RunnerConfig, "contextBudget">>;
+function resolveMemoryConfig(
+  profiles: ModelProfiles,
+  profileName: string,
+): ResolvedMemoryConfig {
+  const profile = profiles.profiles.get(profileName);
+  if (profile === undefined || profiles.memory === undefined) {
+    throw unknownProfileError(profileName, profiles);
+  }
+  const contextProfile = profileToContextProfile(profile);
+  return Object.freeze({
+    profile,
+    contextBudget: deriveModelContextBudget(contextProfile),
+    embedding: profiles.memory.embedding,
+  });
+}
 
-export function readRunnerConfig(
-  overrides: RunnerConfigOverrides = {},
-  profiles?: ModelProfiles,
+export function deriveRunnerConfig(
+  snapshot: ResolvedPublicConfig,
+  selection: RunnerConfigSelection,
 ): RunnerConfig {
-  if (profiles !== undefined) {
-    const profileName = overrides.profileName ?? profiles.defaultProfile;
-    const profile = profiles.profiles.get(profileName);
-    if (profile === undefined) {
-      throw unknownProfileError(profileName, profiles);
+  if (snapshot.mode === "profile") {
+    const profileName = selection.profileName ?? snapshot.profiles.defaultProfile;
+    const template = snapshot.templates.get(profileName);
+    if (template === undefined) {
+      throw unknownProfileError(profileName, snapshot.profiles);
     }
-    return runnerConfigFromProfile(profile, overrides, profiles);
+    return runnerConfigFromTemplate(template, selection.sessionId);
   }
-  if (overrides.profileName !== undefined) {
+
+  if (selection.profileName !== undefined) {
     throw new Error(
-      `Cannot select model profile ${JSON.stringify(overrides.profileName)} because TINKER_MODELS is not configured.`,
+      `Cannot select model profile ${JSON.stringify(selection.profileName)} because TINKER_MODELS is not configured.`,
     );
   }
-
-  return runnerConfigFromEnv(overrides);
+  return runnerConfigFromTemplate(snapshot.template, selection.sessionId);
 }
 
-function runnerConfigFromProfile(
+function runnerConfigTemplateFromProfile(
+  environment: Extract<ParsedPublicEnvironment, { mode: "profile" }>,
   profile: ModelProfile,
-  overrides: RunnerConfigOverrides,
-  profiles: ModelProfiles,
-): RunnerConfig {
-  const contextProfile = overrides.contextProfile ?? profileToContextProfile(profile);
-  const contextBudget = deriveModelContextBudget(contextProfile);
-
-  return {
-    sessionId: overrides.sessionId ?? (createUuidV7() as SessionId),
-    workspaceRoot: path.resolve(
-      overrides.workspaceRoot ?? process.env.TINKER_WORKSPACE ?? process.cwd(),
-    ),
+): RunnerConfigTemplate {
+  const contextProfile = profileToContextProfile(profile);
+  return Object.freeze({
+    workspaceRoot: environment.workspaceRoot,
     modelName: profile.model,
     apiKey: profile.apiKey,
     apiBase: profile.apiBase,
-    maxIterations:
-      overrides.maxIterations ??
-      parsePositiveInteger(
-        process.env.TINKER_MAX_ITERATIONS,
-        DEFAULT_MAX_ITERATIONS,
-        "TINKER_MAX_ITERATIONS",
-      ),
+    maxIterations: environment.maxIterations,
     includeReasoningContent: profile.includeReasoningContent,
     stream: profile.stream,
     contextProfile,
-    contextBudget,
+    contextBudget: deriveModelContextBudget(contextProfile),
     profileName: profile.name,
-    profiles,
     inputModalities: profile.inputModalities,
     ...(profile.tokenEstimator === undefined
       ? {}
       : { tokenEstimator: profile.tokenEstimator }),
-  };
+  });
 }
 
-function runnerConfigFromEnv(overrides: RunnerConfigOverrides): RunnerConfig {
-  const modelName = overrides.modelName ?? readRequiredEnv("TINKER_MODEL");
-  validateWebFetchRefinerModel(modelName);
-  const contextProfile = overrides.contextProfile ?? readModelContextProfileFromEnv();
-  const contextBudget = deriveModelContextBudget(contextProfile);
-
-  return {
-    sessionId: overrides.sessionId ?? (createUuidV7() as SessionId),
-    workspaceRoot: path.resolve(
-      overrides.workspaceRoot ?? process.env.TINKER_WORKSPACE ?? process.cwd(),
-    ),
-    modelName,
-    maxIterations:
-      overrides.maxIterations ??
-      parsePositiveInteger(
-        process.env.TINKER_MAX_ITERATIONS,
-        DEFAULT_MAX_ITERATIONS,
-        "TINKER_MAX_ITERATIONS",
-      ),
-    includeReasoningContent:
-      overrides.includeReasoningContent ??
-      parseBoolean(
-        process.env.TINKER_INCLUDE_REASONING_CONTENT,
-        DEFAULT_INCLUDE_REASONING_CONTENT,
-        "TINKER_INCLUDE_REASONING_CONTENT",
-      ),
-    stream:
-      overrides.stream ??
-      parseBoolean(process.env.TINKER_STREAM, DEFAULT_STREAM, "TINKER_STREAM"),
+function runnerConfigTemplateFromEnvironment(
+  environment: Extract<ParsedPublicEnvironment, { mode: "env" }>,
+): RunnerConfigTemplate {
+  const contextProfile = createModelContextProfile({
+    contextWindowTokens: environment.contextWindowTokens,
+    maxSupportedOutputTokens: environment.maxSupportedOutputTokens,
+  });
+  return Object.freeze({
+    workspaceRoot: environment.workspaceRoot,
+    modelName: environment.modelName,
+    apiKey: environment.apiKey,
+    apiBase: environment.apiBase,
+    maxIterations: environment.maxIterations,
+    includeReasoningContent: environment.includeReasoningContent,
+    stream: environment.stream,
     contextProfile,
-    contextBudget,
-    inputModalities: overrides.inputModalities ?? Object.freeze(["text"]),
-    ...(overrides.tokenEstimator === undefined
-      ? {}
-      : { tokenEstimator: overrides.tokenEstimator }),
-  };
-}
-
-export function createModelClientFromEnv(
-  config: Pick<
-    RunnerConfig,
-    | "modelName"
-    | "includeReasoningContent"
-    | "stream"
-    | "contextBudget"
-    | "apiKey"
-    | "apiBase"
-  > &
-    Partial<Pick<RunnerConfig, "inputModalities" | "tokenEstimator">>,
-): ModelClient {
-  const fakeMode = process.env.TINKER_TEST_FAKE_MODEL;
-  if (fakeMode !== undefined && fakeMode !== "") {
-    return new FakeModelClient(fakeMode, {
-      model: config.modelName,
-      contextBudget: config.contextBudget,
-    });
-  }
-
-  const apiKey = config.apiKey ?? readRequiredEnv("TINKER_API_KEY");
-  const baseURL = config.apiBase ?? readRequiredEnv("TINKER_BASE_URL");
-
-  return new OpenAIChatModelClient({
-    apiKey,
-    baseURL,
-    includeReasoningContent: config.includeReasoningContent,
-    model: config.modelName,
-    stream: config.stream,
-    contextBudget: config.contextBudget,
-    inputModalities: config.inputModalities ?? Object.freeze(["text"]),
-    ...(config.tokenEstimator === undefined
-      ? {}
-      : { tokenEstimator: config.tokenEstimator }),
+    contextBudget: deriveModelContextBudget(contextProfile),
+    inputModalities: Object.freeze(["text"] as const),
   });
 }
 
-export function createRunnerModelClient(
-  config: Pick<
-    RunnerConfig,
-    | "modelName"
-    | "includeReasoningContent"
-    | "stream"
-    | "contextBudget"
-    | "apiKey"
-    | "apiBase"
-  > &
-    Partial<Pick<RunnerConfig, "inputModalities" | "tokenEstimator">>,
-  injected?: ModelClient,
-): ModelClient {
-  return injected ?? createModelClientFromEnv(config);
-}
-
-export function createWebFetchRefinerFromEnv(
-  config: Pick<
-    RunnerConfig,
-    | "modelName"
-    | "includeReasoningContent"
-    | "stream"
-    | "contextBudget"
-    | "apiKey"
-    | "apiBase"
-  > &
-    Partial<Pick<RunnerConfig, "inputModalities" | "tokenEstimator">>,
-): Refiner {
-  return createModelRefiner({
-    createModelClient: () => createModelClientFromEnv(config),
-    contextBudget: config.contextBudget,
-  });
+function runnerConfigFromTemplate(
+  template: RunnerConfigTemplate,
+  sessionId: SessionId,
+): RunnerConfig {
+  return Object.freeze({ ...template, sessionId });
 }
 
 export function eventLogPath(workspaceRoot: string, sessionId: SessionId): string {
@@ -264,63 +220,3 @@ export function observationLogPath(
 export function promptHistoryPath(workspaceRoot: string): string {
   return path.join(workspaceRoot, ".tinker", "prompt-history.jsonl");
 }
-
-function readRequiredEnv(name: string): string {
-  const value = process.env[name];
-  if (value === undefined || value.trim() === "") {
-    throw new Error(`${name} is required. Put it in .env or the process environment.`);
-  }
-  return value.trim();
-}
-
-function parsePositiveInteger(
-  value: string | undefined,
-  fallback: number,
-  name: string,
-): number {
-  if (value === undefined) {
-    return fallback;
-  }
-
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed < 1) {
-    throw new Error(`${name} must be a positive integer; received ${value}`);
-  }
-
-  return parsed;
-}
-
-function parseBoolean(
-  value: string | undefined,
-  fallback: boolean,
-  name: string,
-): boolean {
-  if (value === undefined || value.trim() === "") {
-    return fallback;
-  }
-
-  const normalized = value.trim().toLowerCase();
-  if (["1", "true", "yes", "on"].includes(normalized)) {
-    return true;
-  }
-  if (["0", "false", "no", "off"].includes(normalized)) {
-    return false;
-  }
-
-  throw new Error(
-    `${name} must be one of true/false, 1/0, yes/no, or on/off; received ${value}`,
-  );
-}
-
-function validateWebFetchRefinerModel(mainModelName: string): void {
-  const refinerModel = process.env.TINKER_WEBFETCH_REFINE_MODEL;
-  if (
-    refinerModel !== undefined &&
-    refinerModel.trim() !== "" &&
-    refinerModel !== mainModelName
-  ) {
-    throw new Error(
-      `TINKER_WEBFETCH_REFINE_MODEL must match TINKER_MODEL in F2; received ${JSON.stringify(refinerModel)} for main model ${JSON.stringify(mainModelName)}.`,
-    );
-  }
-}

package/src/cli/index.ts

@@ -1,29 +1,41 @@
 #!/usr/bin/env bun
-import { runOneShot } from "./run-runner";
-import { runTui } from "./tui-runner";
 
-const [, , command, ...args] = process.argv;
+type MainModule = typeof import("./main");
 
-if (command === "run") {
-  const prompt = args.join(" ").trim();
-
-  if (prompt === "") {
-    process.stderr.write('Usage: tinker run "prompt"\n');
-    process.exit(2);
+export async function runExecutable(
+  input: {
+    readonly args: readonly string[];
+    readonly stdin: AsyncIterable<unknown>;
+    readonly stdout: NodeJS.WriteStream;
+    readonly stderr: NodeJS.WriteStream;
+    readonly cwd: string;
+    readonly env: NodeJS.ProcessEnv;
+  } = {
+    args: process.argv.slice(2),
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    cwd: process.cwd(),
+    env: process.env,
+  },
+  loadMain: () => Promise<MainModule> = () => import("./main"),
+): Promise<number> {
+  let mainModule: MainModule;
+  try {
+    mainModule = await loadMain();
+  } catch {
+    input.stderr.write("Tinker failed to start. Reinstall tinker-agent.\n");
+    return 1;
   }
 
-  const exitCode = await runOneShot(prompt);
-  process.exit(exitCode);
-}
-
-if (command === "--profile" || command === "-p") {
-  const profileName = args[0];
-  if (profileName === undefined) {
-    process.stderr.write("Usage: tinker --profile <profile-name>\n");
-    process.exit(2);
+  try {
+    return await mainModule.main(input);
+  } catch {
+    input.stderr.write("Tinker failed unexpectedly.\n");
+    return 1;
   }
-  await runTui({ profileName });
-  process.exit(0);
 }
 
-await runTui();
+if (import.meta.main) {
+  process.exitCode = await runExecutable();
+}