tau-coding-agent 0.1.5 → 0.1.6

package/extensions/answer.ts

@@ -95,14 +95,19 @@ interface ModelRequestAuth {
   model: Model<Api>;
   apiKey?: string;
   headers?: Record<string, string>;
+  env?: Record<string, string>;
 }
 
 type ModelAuthLookup = {
   find: (provider: string, modelId: string) => Model<Api> | undefined;
-  getApiKeyAndHeaders: (
-    model: Model<Api>,
-  ) => Promise<
-    { ok: true; apiKey?: string; headers?: Record<string, string> } | { ok: false; error: string }
+  getApiKeyAndHeaders: (model: Model<Api>) => Promise<
+    | {
+        ok: true;
+        apiKey?: string;
+        headers?: Record<string, string>;
+        env?: Record<string, string>;
+      }
+    | { ok: false; error: string }
   >;
 };
 
@@ -149,7 +154,7 @@ async function resolveModelRequestAuth(
   model: Model<Api>,
 ): Promise<ModelRequestAuth | null> {
   const auth = await modelRegistry.getApiKeyAndHeaders(model);
-  return auth.ok ? { model, apiKey: auth.apiKey, headers: auth.headers } : null;
+  return auth.ok ? { model, apiKey: auth.apiKey, headers: auth.headers, env: auth.env } : null;
 }
 
 /**
@@ -542,6 +547,7 @@ export default function (pi: ExtensionAPI) {
               {
                 apiKey: extractionSelection.apiKey,
                 headers: extractionSelection.headers,
+                env: extractionSelection.env,
                 signal: loader.signal,
               },
             );

package/extensions/btw.ts

@@ -1,7 +1,13 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, ThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  InMemoryCredentialStore,
+  type AssistantMessage,
+  type Provider,
+  type ThinkingLevel,
+} from "@earendil-works/pi-ai";
 import {
   DefaultResourceLoader,
+  ModelRuntime,
   SessionManager,
   buildSessionContext,
   createAgentSession,
@@ -59,6 +65,15 @@ type ActiveBtwRequest = {
   abort?: () => Promise<void>;
 };
 
+type BtwModelRegistry = ExtensionCommandContext["modelRegistry"];
+
+type BtwModelRuntimeState = {
+  runtime: ModelRuntime;
+  providers: Map<string, Provider>;
+};
+
+const btwModelRuntimes = new WeakMap<BtwModelRegistry, Promise<BtwModelRuntimeState>>();
+
 export default function btwExtension(pi: ExtensionAPI): void {
   let activeRequest: ActiveBtwRequest | null = null;
   let statusTimer: ReturnType<typeof setInterval> | null = null;
@@ -227,11 +242,12 @@ async function runBtwRequest(
   });
   await resourceLoader.reload();
 
+  const modelRuntime = await createBtwModelRuntime(snapshot.modelRegistry, snapshot.model.provider);
   const { session } = await createAgentSession({
     cwd: snapshot.cwd,
     model: snapshot.model,
     thinkingLevel: snapshot.thinkingLevel,
-    modelRegistry: snapshot.modelRegistry,
+    modelRuntime,
     resourceLoader,
     tools: BTW_TOOL_NAMES,
     sessionManager,
@@ -269,6 +285,61 @@ async function runBtwRequest(
   }
 }
 
+async function createBtwModelRuntime(
+  modelRegistry: BtwModelRegistry,
+  providerId: string,
+): Promise<ModelRuntime> {
+  const provider = modelRegistry.getProvider(providerId);
+  if (!provider) {
+    throw new Error(`Model provider is unavailable: ${providerId}`);
+  }
+
+  const state = await getBtwModelRuntimeState(modelRegistry);
+  if (state.providers.get(providerId) !== provider) {
+    state.runtime.registerNativeProvider(withParentAuth(provider, modelRegistry));
+    state.providers.set(providerId, provider);
+  }
+  return state.runtime;
+}
+
+async function getBtwModelRuntimeState(
+  modelRegistry: BtwModelRegistry,
+): Promise<BtwModelRuntimeState> {
+  let state = btwModelRuntimes.get(modelRegistry);
+  if (!state) {
+    state = ModelRuntime.create({
+      credentials: new InMemoryCredentialStore(),
+      modelsPath: null,
+    }).then((runtime) => ({ runtime, providers: new Map() }));
+    btwModelRuntimes.set(modelRegistry, state);
+  }
+
+  try {
+    return await state;
+  } catch (error) {
+    if (btwModelRuntimes.get(modelRegistry) === state) {
+      btwModelRuntimes.delete(modelRegistry);
+    }
+    throw error;
+  }
+}
+
+function withParentAuth(provider: Provider, modelRegistry: BtwModelRegistry): Provider {
+  return {
+    ...provider,
+    refreshModels: undefined, // The parent runtime owns model catalog refreshes.
+    auth: {
+      ...provider.auth,
+      apiKey: {
+        name: `${provider.name} session authentication`,
+        async resolve() {
+          return modelRegistry.getProviderAuth(provider.id);
+        },
+      },
+    },
+  };
+}
+
 function seedSessionManager(sessionManager: SessionManager, messages: AgentMessage[]): void {
   type SessionMessageInput = Parameters<SessionManager["appendMessage"]>[0];
 

package/extensions/insights.ts

@@ -27,6 +27,7 @@ import {
 } from "@earendil-works/pi-tui";
 import { createHash, randomBytes } from "node:crypto";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 
 // --- Constants ---
@@ -141,6 +142,7 @@ type ConfiguredModelSelection = {
   model: Model<Api>;
   apiKey?: string;
   headers?: Record<string, string>;
+  env?: Record<string, string>;
 };
 
 type ReadonlySessionManager = Pick<
@@ -562,9 +564,37 @@ async function runInsightsCommand(
     return;
   }
 
+  let reportPath: string | undefined;
+  try {
+    reportPath = await saveInsightsReport(result.reportMarkdown, result.generatedAt);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    ctx.ui.notify(`Failed to save insights report: ${message}`, "warning");
+  }
+
   await ctx.ui.custom<void>((tui, theme, _kb, done) => {
     return new InsightsReportComponent(result, tui, theme, done);
   });
+
+  if (reportPath) {
+    ctx.ui.notify(`Insights report saved to ${reportPath}`, "info");
+  }
+}
+
+async function saveInsightsReport(reportMarkdown: string, generatedAt: string): Promise<string> {
+  const timestamp = generatedAt.replace(/[:.]/g, "-");
+  const reportPath = path.join(os.tmpdir(), `tau-insights-${timestamp}.md`);
+  const reportFile = await fs.open(reportPath, "wx", 0o600);
+
+  try {
+    await reportFile.writeFile(`${reportMarkdown.trimEnd()}\n`, "utf8");
+    await reportFile.close();
+    return reportPath;
+  } catch (error) {
+    await reportFile.close().catch(() => undefined);
+    await fs.rm(reportPath, { force: true }).catch(() => undefined);
+    throw error;
+  }
 }
 
 async function runInsightsPipeline(
@@ -749,7 +779,12 @@ async function getConfiguredModelSelection(
 
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
   if (!auth.ok) return null;
-  return { model: ctx.model, apiKey: auth.apiKey, headers: auth.headers };
+  return {
+    model: ctx.model,
+    apiKey: auth.apiKey,
+    headers: auth.headers,
+    env: auth.env,
+  };
 }
 
 async function listTargets(
@@ -1342,6 +1377,7 @@ async function extractFacet(
     {
       apiKey: selection.apiKey,
       headers: selection.headers,
+      env: selection.env,
       signal,
     },
   );
@@ -1514,6 +1550,7 @@ async function synthesizeReport(
     {
       apiKey: selection.apiKey,
       headers: selection.headers,
+      env: selection.env,
       signal,
     },
   );

package/extensions/loop.ts

@@ -54,6 +54,7 @@ type ModelRequestAuth = {
   model: Model<Api>;
   apiKey?: string;
   headers?: Record<string, string>;
+  env?: Record<string, string>;
 };
 
 async function withPromptSignal<T>(pi: ExtensionAPI, run: () => Promise<T>): Promise<T> {
@@ -137,13 +138,20 @@ async function selectSummaryModel(ctx: ExtensionContext): Promise<ModelRequestAu
 
       const auth = await ctx.modelRegistry.getApiKeyAndHeaders(candidate);
       if (auth.ok) {
-        return { model: candidate, apiKey: auth.apiKey, headers: auth.headers };
+        return {
+          model: candidate,
+          apiKey: auth.apiKey,
+          headers: auth.headers,
+          env: auth.env,
+        };
       }
     }
   }
 
   const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
-  return auth.ok ? { model: ctx.model, apiKey: auth.apiKey, headers: auth.headers } : null;
+  return auth.ok
+    ? { model: ctx.model, apiKey: auth.apiKey, headers: auth.headers, env: auth.env }
+    : null;
 }
 
 async function summarizeBreakoutCondition(
@@ -165,7 +173,7 @@ async function summarizeBreakoutCondition(
   const response = await complete(
     selection.model,
     { systemPrompt: SUMMARY_SYSTEM_PROMPT, messages: [userMessage] },
-    { apiKey: selection.apiKey, headers: selection.headers },
+    { apiKey: selection.apiKey, headers: selection.headers, env: selection.env },
   );
 
   if (response.stopReason === "aborted" || response.stopReason === "error") {
@@ -518,6 +526,9 @@ export default function loopExtension(pi: ExtensionAPI): void {
         auth.headers,
         instructionParts,
         event.signal,
+        ctx.thinkingLevel,
+        undefined, // Use Pi's default summarization stream.
+        auth.env,
       );
       return { compaction };
     } catch (error) {

package/extensions/memory.ts

@@ -1,5 +1,11 @@
 import { complete } from "@earendil-works/pi-ai/compat";
-import { StringEnum, type Api, type Model, type UserMessage } from "@earendil-works/pi-ai";
+import {
+  StringEnum,
+  type Api,
+  type Model,
+  type Usage,
+  type UserMessage,
+} from "@earendil-works/pi-ai";
 import {
   defineTool,
   withFileMutationQueue,
@@ -171,6 +177,11 @@ type DreamResult = {
   summaryPath: string | null;
 };
 
+type DreamExecution = {
+  result: DreamResult;
+  usage?: Usage;
+};
+
 type AutoDreamStatus = {
   coreLines: number;
   coreChars: number;
@@ -189,6 +200,7 @@ type ModelSelection = {
   model: Model<Api>;
   apiKey?: string;
   headers?: Record<string, string>;
+  env?: Record<string, string>;
 };
 
 class MemoryReadmeMissingError extends Error {
@@ -204,12 +216,17 @@ async function toolDream(
   cwd: string,
   ctx: ExtensionContext,
   reason?: string,
-): Promise<{ content: Array<{ type: "text"; text: string }>; details: DreamResult }> {
+): Promise<{
+  content: Array<{ type: "text"; text: string }>;
+  details: DreamResult;
+  usage?: Usage;
+}> {
   try {
-    const result = await runMemoryDream(cwd, ctx, reason);
+    const execution = await runMemoryDream(cwd, ctx, reason);
     return {
-      content: [{ type: "text", text: result.summary }],
-      details: result,
+      content: [{ type: "text", text: execution.result.summary }],
+      details: execution.result,
+      usage: execution.usage,
     };
   } catch (error) {
     if (error instanceof MemoryReadmeMissingError) {
@@ -369,7 +386,7 @@ async function runMemoryDream(
   cwd: string,
   ctx: ExtensionContext,
   reason?: string,
-): Promise<DreamResult> {
+): Promise<DreamExecution> {
   const paths = getMemoryPaths(cwd);
   const lockPaths = [
     paths.readmeFile,
@@ -394,13 +411,15 @@ async function runMemoryDream(
     const summary = "Memory dream: nothing to consolidate.";
     notify(ctx, summary, "info");
     return {
-      summary,
-      updatedBlocks: [],
-      consumedLogs: 0,
-      consumedCompactions: 0,
-      lastDreamAt: snapshot.state?.lastDreamAt ?? nowIso(),
-      lastDreamedLogAt: snapshot.state?.lastDreamedLogAt ?? null,
-      summaryPath: null,
+      result: {
+        summary,
+        updatedBlocks: [],
+        consumedLogs: 0,
+        consumedCompactions: 0,
+        lastDreamAt: snapshot.state?.lastDreamAt ?? nowIso(),
+        lastDreamedLogAt: snapshot.state?.lastDreamedLogAt ?? null,
+        summaryPath: null,
+      },
     };
   }
 
@@ -414,6 +433,7 @@ async function runMemoryDream(
     {
       apiKey: selection.apiKey,
       headers: selection.headers,
+      env: selection.env,
       signal: ctx.signal,
     },
   );
@@ -464,7 +484,7 @@ async function runMemoryDream(
     );
   }
 
-  return withMemoryMutationQueue(lockPaths, async () => {
+  const result = await withMemoryMutationQueue(lockPaths, async () => {
     ensureMemoryInitialized(await pathExists(paths.memoryRoot));
 
     const currentReplay = await collectDreamReplay(cwd);
@@ -512,6 +532,8 @@ async function runMemoryDream(
       summaryPath,
     };
   });
+
+  return { result, usage: response.usage };
 }
 
 async function loadMemoryPrompt(cwd: string): Promise<string | undefined> {
@@ -962,6 +984,7 @@ async function selectDreamModel(ctx: ExtensionContext): Promise<ModelSelection>
     model: ctx.model,
     apiKey: auth.apiKey,
     headers: auth.headers,
+    env: auth.env,
   };
 }
 

package/extensions/review/models.ts

@@ -510,7 +510,7 @@ export async function resolveModels(
   requestedModels: string[],
   currentThinkingLevel: ReviewThinkingLevel,
 ): Promise<ResolvedReviewModel[]> {
-  ctx.modelRegistry.refresh();
+  await ctx.modelRegistry.refresh();
   const currentProvider = typeof ctx.model?.provider === "string" ? ctx.model.provider : undefined;
   const currentModelId = ctx.model?.id;
   const allModels = ctx.modelRegistry.getAll();

package/extensions/review/prompts.ts

@@ -63,7 +63,7 @@ Only flag issues with a concrete exploit path or trust-boundary failure introduc
     suffix: " specializing in reuse analysis",
     qualifier: " reuse",
     context: `Review the changes for potential reuse issues, such as:
-1. Search for existing capabilities that could replace newly written code: standard library APIs, native platform features, already-installed dependencies, and existing utilities/helpers. Start with ripgrep-style searches (use the grep tool first), then inspect utility directories, shared modules, and adjacent files.
+1. Search for existing capabilities that could replace newly written code: standard library APIs, native platform features, already-installed dependencies, and existing utilities/helpers. Search for relevant names and behavior, then go beyond string matches by inspecting adjacent files, utility files and directories, and shared modules.
 2. Flag any new function that duplicates existing functionality. Suggest the existing function, API, or feature to use instead.
 3. Flag any inline logic that could use an existing capability — hand-rolled standard-library behavior, string manipulation, manual path handling, custom environment checks, ad-hoc type guards, native platform features, and similar patterns are common candidates.
 4. Flag new dependencies when the standard library, runtime/platform, or an already-installed dependency provides the same capability or behavior.
@@ -76,7 +76,7 @@ Only flag issues with a concrete exploit path or trust-boundary failure introduc
 1. Redundant state: state that duplicates existing state, cached values that could be derived, observers/effects that could be direct calls.
 2. Parameter sprawl: adding new parameters to a function instead of generalizing or restructuring existing ones.
 3. Copy-paste with slight variation: near-duplicate code blocks that should be unified with a shared abstraction.
-4. Leaky abstractions: exposing internal details that should be encapsulated, or breaking existing abstraction boundaries.
+4. Layering and leaky abstractions: logic that lives in the wrong layer, exposes internal details that should be encapsulated, or breaks existing abstraction boundaries.
 5. Stringly-typed code: using raw strings where constants, enums (string unions), or branded types already exist in the codebase.
 6. Simplicity/YAGNI: prefer simple, direct solutions over wrappers, abstractions, configuration, options, extensibility, or scaffolding without clear reuse value or explicit need. Prefer deletion or direct code until the second use appears.
 7. Shrinkage: flag code that preserves behavior with fewer branches, lines, moving parts, or custom helpers. Do not shrink away input validation at trust boundaries, data-loss error handling, security measures, or accessibility basics.
@@ -141,10 +141,10 @@ export function buildProjectReviewGuidelinesSection(projectGuidelines: string |
 export const SUBMIT_TOOL_RETRY_PROMPT = `You did not call {SUBMIT_TOOL} as instructed. You must call that tool exactly once with the final payload. Do not output any text, only call the {SUBMIT_TOOL} when you're done.`;
 
 export const REVIEW_OUTPUT_CONTRACT_PROMPT = `Requirements:
-- Never output findings or notes as text or write them to files.
+- Never output findings as text or write them to files.
 - Always call submit_review exactly once as your final action.
 - If no issues are found, pass an empty array of findings to submit_review.
-- If uncertain, pass a note to submit_review.`;
+- Omit uncertain or speculative findings.`;
 
 export const REVIEW_FOCUS_PROMPT = `You are an expert code reviewer{FOCUS_SUFFIX}.
 

package/extensions/review/submit-review-tool.ts

@@ -35,11 +35,6 @@ const SUBMIT_REVIEW_PARAMS = Type.Object(
       ),
       { description: "Final review findings" },
     ),
-    note: Type.Optional(
-      Type.String({
-        description: "Optional note when submitting zero findings or explaining uncertainty.",
-      }),
-    ),
   },
   { additionalProperties: false },
 );
@@ -51,6 +46,7 @@ const submitReviewTool = defineTool({
   promptSnippet: "Submit the final review findings",
   promptGuidelines: ["Use submit_review exactly once as your final action."],
   parameters: SUBMIT_REVIEW_PARAMS,
+  constrainedSampling: { type: "json_schema", strict: "prefer" },
 
   async execute(_toolCallId, params) {
     return {

package/extensions/review/submit-triage-tool.ts

@@ -44,6 +44,7 @@ const submitTriageTool = defineTool({
   promptSnippet: "Submit the final PR feedback triage",
   promptGuidelines: ["Use submit_triage exactly once as your final action."],
   parameters: SUBMIT_TRIAGE_PARAMS,
+  constrainedSampling: { type: "json_schema", strict: "prefer" },
 
   async execute(_toolCallId, params) {
     return {