bazilion 0.16.0 → 0.17.0

package/dist/worker.js

@@ -1108,6 +1108,41 @@ function qmdBackend(root, options = {}) {
   };
 }
 
+// ../daemon/src/lib/coding-environment/receipt-reference.ts
+function codingLogReference(content) {
+  const parsed = objectFrom(textContent(content));
+  if (!parsed) return null;
+  return referenceFrom(parsed) ?? referenceFrom(objectFrom(parsed.receipt));
+}
+function referenceFrom(value) {
+  if (!value) return null;
+  const commandId = value.id;
+  const teamId = value.teamId;
+  if (typeof commandId !== "string" || commandId.length === 0) return null;
+  if (typeof teamId !== "string" || teamId.length === 0) return null;
+  return { commandId, teamId };
+}
+function textContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let out = "";
+  for (const block of content) {
+    if (block && block.type === "text" && typeof block.text === "string") out += block.text;
+  }
+  return out;
+}
+function objectFrom(value) {
+  if (typeof value === "string") {
+    try {
+      return objectFrom(JSON.parse(value));
+    } catch {
+      return null;
+    }
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  return value;
+}
+
 // ../daemon/src/runtime/pi/events.ts
 function translatePiEvent(e) {
   switch (e.type) {
@@ -1147,6 +1182,22 @@ function translatePiEvent(e) {
       }
       return out;
     }
+    case "tool_execution_update": {
+      if (e.toolName !== "coding_command") return [];
+      const progress = e.partialResult?.details?.codingProgress;
+      if (!progress || typeof progress.id !== "string" || typeof progress.commandId !== "string" || typeof progress.output !== "string" || typeof progress.elapsedMs !== "number")
+        return [];
+      return [
+        {
+          type: "coding_progress",
+          id: progress.id,
+          commandId: progress.commandId,
+          output: progress.output,
+          truncated: progress.truncated === true,
+          elapsedMs: Math.max(0, Math.floor(progress.elapsedMs))
+        }
+      ];
+    }
     case "tool_execution_end": {
       if (e.toolName === "ask_user")
         return [
@@ -1254,14 +1305,22 @@ function piMessagesToProviderView(messages, questionResultVisible) {
       }
       case "toolResult": {
         const tr = m;
-        if (["repository_context", "coding_environment", "coding_command", "coding_receipt"].includes(
-          tr.toolName ?? ""
-        )) {
+        if ([
+          "repository_context",
+          "coding_environment",
+          "coding_command",
+          "coding_receipt",
+          "coding_log",
+          // BAZ-042: a snapshot result names withheld paths, so history must not render it.
+          "source_snapshot"
+        ].includes(tr.toolName ?? "")) {
+          const codingLog = codingLogReference(tr.content);
           out.push({
             role: "tool",
             toolCallId: tr.toolCallId,
             toolName: tr.toolName,
-            content: "Coding context or command evidence retained privately. Captured transport output follows its communication approval; ask the Agent for the relevant result."
+            content: "Coding context or command evidence retained privately. Captured transport output follows its communication approval; ask the Agent for the relevant result.",
+            ...codingLog ? { codingLog } : {}
           });
           break;
         }
@@ -1298,6 +1357,107 @@ function extractResultReference(value) {
   return typeof id === "string" && /^[a-f0-9-]{36}$/.test(id) ? { resultId: id } : void 0;
 }
 
+// ../daemon/src/lib/coding-environment/diagnostics.ts
+var CODING_OUTPUT_BYTES = 64 * 1024;
+var CODING_RETAINED_BYTES = 2 * 1024 * 1024;
+var CODING_LIVE_BYTES = 8 * 1024;
+function diagnosticTail(value, limit) {
+  const bytes = Buffer.from(value);
+  if (bytes.length <= limit) return { text: value, truncated: false };
+  let offset = bytes.length - limit;
+  while (offset < bytes.length && ((bytes[offset] ?? 0) & 192) === 128) offset++;
+  return { text: bytes.subarray(offset).toString("utf8"), truncated: true };
+}
+var CodingDiagnostics = class {
+  decoder = new TextDecoder();
+  secrets;
+  lookbehind;
+  retainBytes;
+  pending = "";
+  text = "";
+  truncated = false;
+  observedBytes = 0;
+  redactions = 0;
+  finished = false;
+  constructor(secrets, retainBytes = CODING_OUTPUT_BYTES) {
+    this.secrets = [...new Set(secrets.filter(Boolean))].sort((a, b) => b.length - a.length);
+    this.lookbehind = Math.max(1, ...this.secrets.map((secret) => secret.length)) - 1;
+    this.retainBytes = retainBytes;
+  }
+  append(bytes) {
+    if (this.finished) throw new Error("Coding diagnostics already finalized");
+    this.observedBytes += bytes.length;
+    for (let offset = 0; offset < bytes.length; offset += 8192) {
+      this.pending += this.decoder.decode(bytes.subarray(offset, offset + 8192), { stream: true });
+      this.flush(false);
+    }
+  }
+  /**
+   * Redacted cumulative tail for a live update. Unlike `finish()` this does not seal
+   * the diagnostics: more output may follow. It deliberately excludes the trailing
+   * lookbehind bytes so a credential split across chunks cannot leak before the next
+   * chunk resolves it.
+   */
+  preview(limit = CODING_LIVE_BYTES) {
+    return diagnosticTail(this.text, limit);
+  }
+  finish() {
+    if (!this.finished) {
+      this.pending += this.decoder.decode();
+      this.flush(true);
+      this.finished = true;
+    }
+    return {
+      diagnostic: this.text,
+      truncated: this.truncated,
+      observedBytes: this.observedBytes,
+      redacted: this.redactions > 0
+    };
+  }
+  flush(final) {
+    let end = final ? this.pending.length : Math.max(0, this.pending.length - this.lookbehind);
+    const last = this.pending.charCodeAt(end - 1);
+    if (!final && last >= 55296 && last <= 56319) end--;
+    let offset = 0;
+    let safe = "";
+    while (offset < end) {
+      const secret = this.secrets.find((value) => this.pending.startsWith(value, offset));
+      if (secret) {
+        safe += "[redacted]";
+        this.redactions++;
+        offset += secret.length;
+      } else {
+        const code = this.pending.charCodeAt(offset);
+        const char = this.pending[offset] ?? "";
+        safe += code < 32 && code !== 9 && code !== 10 || code >= 127 && code <= 159 ? `\\u${code.toString(16).padStart(4, "0")}` : char;
+        offset++;
+      }
+    }
+    this.pending = this.pending.slice(offset);
+    const tail = diagnosticTail(this.text + safe, this.retainBytes);
+    this.text = tail.text;
+    this.truncated ||= tail.truncated;
+  }
+};
+function codingSecrets(env) {
+  const values = /* @__PURE__ */ new Set();
+  function collect(value, depth = 0) {
+    if (depth > 8) return;
+    if (typeof value === "string" && value.length >= 4) values.add(value);
+    else if (value && typeof value === "object")
+      for (const entry of Object.values(value)) collect(entry, depth + 1);
+  }
+  for (const [key, value] of Object.entries(env)) {
+    if (!value || !/KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH/i.test(key)) continue;
+    values.add(value);
+    try {
+      collect(JSON.parse(value));
+    } catch {
+    }
+  }
+  return [...values];
+}
+
 // ../daemon/src/lib/result-source.ts
 import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, openSync as openSync2, readSync, realpathSync as realpathSync2 } from "fs";
 import { basename as basename2, join as join13 } from "path";
@@ -1387,67 +1547,6 @@ function validateCodingCommand(input) {
   };
 }
 
-// ../daemon/src/lib/coding-environment/diagnostics.ts
-var CODING_OUTPUT_BYTES = 64 * 1024;
-function diagnosticTail(value, limit) {
-  const bytes = Buffer.from(value);
-  if (bytes.length <= limit) return { text: value, truncated: false };
-  let offset = bytes.length - limit;
-  while (offset < bytes.length && ((bytes[offset] ?? 0) & 192) === 128) offset++;
-  return { text: bytes.subarray(offset).toString("utf8"), truncated: true };
-}
-var CodingDiagnostics = class {
-  decoder = new TextDecoder();
-  secrets;
-  lookbehind;
-  pending = "";
-  text = "";
-  truncated = false;
-  finished = false;
-  constructor(secrets) {
-    this.secrets = [...new Set(secrets.filter(Boolean))].sort((a, b) => b.length - a.length);
-    this.lookbehind = Math.max(1, ...this.secrets.map((secret) => secret.length)) - 1;
-  }
-  append(bytes) {
-    if (this.finished) throw new Error("Coding diagnostics already finalized");
-    for (let offset = 0; offset < bytes.length; offset += 8192) {
-      this.pending += this.decoder.decode(bytes.subarray(offset, offset + 8192), { stream: true });
-      this.flush(false);
-    }
-  }
-  finish() {
-    if (!this.finished) {
-      this.pending += this.decoder.decode();
-      this.flush(true);
-      this.finished = true;
-    }
-    return { diagnostic: this.text, truncated: this.truncated };
-  }
-  flush(final) {
-    let end = final ? this.pending.length : Math.max(0, this.pending.length - this.lookbehind);
-    const last = this.pending.charCodeAt(end - 1);
-    if (!final && last >= 55296 && last <= 56319) end--;
-    let offset = 0;
-    let safe = "";
-    while (offset < end) {
-      const secret = this.secrets.find((value) => this.pending.startsWith(value, offset));
-      if (secret) {
-        safe += "[redacted]";
-        offset += secret.length;
-      } else {
-        const code = this.pending.charCodeAt(offset);
-        const char = this.pending[offset] ?? "";
-        safe += code < 32 && code !== 9 && code !== 10 || code >= 127 && code <= 159 ? `\\u${code.toString(16).padStart(4, "0")}` : char;
-        offset++;
-      }
-    }
-    this.pending = this.pending.slice(offset);
-    const tail = diagnosticTail(this.text + safe, CODING_OUTPUT_BYTES);
-    this.text = tail.text;
-    this.truncated ||= tail.truncated;
-  }
-};
-
 // ../daemon/src/runtime/coding-directory.ts
 import { realpathSync as realpathSync4 } from "fs";
 import { join as join15 } from "path";
@@ -2895,6 +2994,7 @@ function runCleanupCommand(dockerPath, args, processEnv) {
 
 // ../daemon/src/runtime/pi/coding.ts
 function codingTools(input) {
+  const readSecrets = () => typeof input.secrets === "function" ? input.secrets() : input.secrets ?? [];
   const hostOperations = input.docker ? null : createLocalBashOperations();
   return [
     {
@@ -2935,7 +3035,7 @@ function codingTools(input) {
         { additionalProperties: false }
       ),
       executionMode: "sequential",
-      async execute(toolCallId, params, signal) {
+      async execute(toolCallId, params, signal, onUpdate) {
         const command = validateCodingCommand(params);
         const context = await input.context(command.cwd);
         if (context.instructions.state !== "complete")
@@ -2945,7 +3045,27 @@ function codingTools(input) {
           toolCallId,
           input: command
         });
-        const output = new CodingDiagnostics(input.secrets ?? []);
+        const output = new CodingDiagnostics(readSecrets());
+        let lastProgressAt = 0;
+        const emitProgress = (force) => {
+          if (!onUpdate) return;
+          const now = Date.now();
+          if (!force && now - lastProgressAt < 400) return;
+          lastProgressAt = now;
+          const preview = output.preview(CODING_LIVE_BYTES);
+          onUpdate({
+            content: [{ type: "text", text: preview.text }],
+            details: {
+              codingProgress: {
+                id: toolCallId,
+                commandId: started.id,
+                output: preview.text,
+                truncated: preview.truncated,
+                elapsedMs: Math.max(0, now - started.startedAt)
+              }
+            }
+          });
+        };
         let outcome;
         try {
           if (input.approval)
@@ -2966,8 +3086,16 @@ function codingTools(input) {
           const result = await operations.exec(
             command.command,
             input.docker ? input.root : cwd.path,
-            { onData: (bytes) => output.append(bytes), signal, timeout: command.timeoutSeconds }
+            {
+              onData: (bytes) => {
+                output.append(bytes);
+                emitProgress(false);
+              },
+              signal,
+              timeout: command.timeoutSeconds
+            }
           );
+          emitProgress(true);
           outcome = {
             state: result.exitCode === 0 ? "succeeded" : result.exitCode === null ? "interrupted" : "failed",
             exitCode: result.exitCode,
@@ -3012,6 +3140,74 @@ function codingTools(input) {
           details: { codingEvidence: value }
         };
       }
+    },
+    {
+      name: "coding_log",
+      label: "Read retained command output",
+      description: "Read a bounded page of retained diagnostic output for a coding receipt, or search it. Producing Agents may read their own logs; a teammate must pass the id of the policy-authorized message that carried coding-receipt:<id>. Output is bounded and may be truncated, expired, deleted or unavailable \u2014 report that state honestly and do not infer completeness from an exit code.",
+      parameters: Type.Object(
+        {
+          id: Type.String({ maxLength: 64 }),
+          messageId: Type.Optional(Type.String({ maxLength: 64 })),
+          search: Type.Optional(Type.String({ minLength: 1, maxLength: 256 })),
+          offset: Type.Optional(Type.Integer({ minimum: 0 })),
+          limit: Type.Optional(Type.Integer({ minimum: 1, maximum: 65536 }))
+        },
+        { additionalProperties: false }
+      ),
+      executionMode: "sequential",
+      async execute(_id, params) {
+        const values = params;
+        if (values.search !== void 0) {
+          const result = await input.host.invoke({
+            action: "log-search",
+            id: values.id,
+            query: values.search,
+            ...values.messageId !== void 0 ? { messageId: values.messageId } : {}
+          });
+          return {
+            content: [{ type: "text", text: JSON.stringify(result) }],
+            details: { codingLogSearch: result }
+          };
+        }
+        const value = await input.host.invoke({
+          action: "log",
+          id: values.id,
+          ...values.messageId !== void 0 ? { messageId: values.messageId } : {},
+          ...values.offset !== void 0 ? { offset: values.offset } : {},
+          ...values.limit !== void 0 ? { limit: values.limit } : {}
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(value) }],
+          details: { codingLog: value }
+        };
+      }
+    },
+    {
+      name: "source_snapshot",
+      label: "Capture the current source state",
+      description: "Capture a bounded snapshot of the repository source you are about to work from, and quote its reference in your summary. Call this once before you start editing: the reference is how a later change or verification is tied to the version it actually applies to. It is read-only and never changes the repository. The result may be incomplete \u2014 when it is, say so, because an incomplete snapshot cannot support a claim that code is unchanged. Untracked file content is never included unless you name each path.",
+      parameters: Type.Object(
+        {
+          includeUntracked: Type.Optional(
+            Type.Array(Type.String({ maxLength: 4096 }), { maxItems: 1e3 })
+          )
+        },
+        { additionalProperties: false }
+      ),
+      executionMode: "sequential",
+      async execute(toolCallId, params) {
+        const values = params;
+        const value = await input.host.invoke({
+          action: "snapshot",
+          toolCallId,
+          ...values.includeUntracked ? { includeUntracked: values.includeUntracked } : {}
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify(value) }],
+          details: { sourceSnapshot: value }
+        };
+      }
     }
   ];
 }
@@ -3349,6 +3545,20 @@ function fallbackApi(providerName) {
       return "openai-completions";
   }
 }
+var UnknownModelError = class extends Error {
+  providerName;
+  modelId;
+  // Fields are declared explicitly, not as constructor parameter properties:
+  // worker subprocesses run Node's strip-only TypeScript, which rejects them.
+  constructor(providerName, modelId) {
+    super(
+      `Unknown model "${modelId}" for provider "${providerName}": it is not in that provider's catalog, and no endpoint is configured for it. Choose a catalogued model, or configure an endpoint for a custom one.`
+    );
+    this.name = "UnknownModelError";
+    this.providerName = providerName;
+    this.modelId = modelId;
+  }
+};
 function fallbackPiModel(providerName, modelId, baseUrl) {
   return {
     id: modelId,
@@ -3420,6 +3630,7 @@ async function createProtectedPiRuntime(options) {
 function resolvePiModel(runtime, providerName, modelId, baseUrl) {
   const known = runtime.getModel(piProviderName(providerName), modelId);
   if (known) return baseUrl ? { ...known, baseUrl } : known;
+  if (!baseUrl) throw new UnknownModelError(providerName, modelId);
   return fallbackPiModel(providerName, modelId, baseUrl);
 }
 
@@ -6006,6 +6217,7 @@ async function createBazilionSession(opts) {
   if (repository) bazilionTools.push(repository.tool);
   if (repository && opts.codingHost && shellTools && shellTools.config.sandboxMode === "docker" && !opts.preparedDocker)
     throw new Error("Coding commands require the admitted Docker runtime");
+  const redactionSecrets = uniqueSecrets(codingSecrets(env));
   if (repository && opts.codingHost && shellTools)
     bazilionTools.push(
       ...codingTools({
@@ -6016,7 +6228,7 @@ async function createBazilionSession(opts) {
         lifecycle: opts.dockerLifecycle,
         approval: shellTools.config.approvalMode === "dangerous",
         approvalHost: bashApprovalHost,
-        secrets: Object.entries(env).filter(([key]) => /KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL|AUTH/i.test(key)).map(([, value]) => value ?? "")
+        secrets: () => redactionSecrets
       })
     );
   const customTools = shellTools?.customBash ? [...bazilionTools, shellTools.customBash] : bazilionTools;
@@ -6038,7 +6250,9 @@ async function createBazilionSession(opts) {
     session.agent.getApiKey = async (requestedProvider) => {
       if (requestedProvider !== piProviderName(providerName)) return void 0;
       try {
-        return await refreshApiKey(providerName);
+        const token = await refreshApiKey(providerName);
+        if (token && !redactionSecrets.includes(token)) redactionSecrets.push(token);
+        return token;
       } catch {
         return void 0;
       }
@@ -6123,6 +6337,7 @@ async function createProtectedBazilionSession(opts) {
     sessionId: sessionManager.getSessionId()
   });
   if (repository) bazilionTools.push(repository.tool);
+  const redactionSecrets = uniqueSecrets(protectedRuntimeSecrets(opts.runtime));
   if (repository && opts.codingHost)
     bazilionTools.push(
       ...codingTools({
@@ -6133,7 +6348,7 @@ async function createProtectedBazilionSession(opts) {
         lifecycle: opts.dockerLifecycle,
         approval: true,
         approvalHost: opts.bashApprovalHost,
-        secrets: protectedRuntimeSecrets(opts.runtime)
+        secrets: () => redactionSecrets
       })
     );
   if (!shellTools.customBash) throw new Error("protected Docker bash tool is unavailable");
@@ -6157,7 +6372,7 @@ async function createProtectedBazilionSession(opts) {
   installProtectedCredentialBoundary(
     session,
     opts.runtime.providerName,
-    protectedRuntimeSecrets(opts.runtime),
+    redactionSecrets,
     opts.refreshApiKey
   );
   return sessionHandle(session);
@@ -6208,11 +6423,14 @@ async function createRestrictedReviewSession(opts) {
   installProtectedCredentialBoundary(
     session,
     opts.runtime.providerName,
-    protectedRuntimeSecrets(opts.runtime),
+    uniqueSecrets(protectedRuntimeSecrets(opts.runtime)),
     opts.refreshApiKey
   );
   return sessionHandle(session);
 }
+function uniqueSecrets(values) {
+  return [...new Set(values.filter(Boolean))];
+}
 function materializeProtectedCredentialFile(runtime, scratch) {
   const fields = [...runtime.credentialEnv ?? []];
   if (runtime.credentialFile) {
@@ -6237,8 +6455,7 @@ function createInMemorySettingsManager() {
     }
   });
 }
-function installProtectedCredentialBoundary(session, providerName, initialSecrets, refreshApiKey) {
-  const activeTokens = [...new Set(initialSecrets.filter(Boolean))];
+function installProtectedCredentialBoundary(session, providerName, activeTokens, refreshApiKey) {
   session.agent.state.messages = redactJsonValue(session.agent.state.messages, activeTokens);
   const originalStream = session.agent.streamFunction;
   session.agent.streamFunction = async (model, context, options) => {