bazis 0.99.1 → 0.99.2

package/core/agent/AgentToolExecutor.ts

@@ -7,7 +7,8 @@ import { assertAgentToolHookIdV1, getAgentModuleContributionsV1, type AgentModul
 import type { AgentToolBeforeEffectEventV1, AgentToolEnforcementDecisionV1, AgentToolHookContextV1, AgentToolRequiredHookRefV1, AgentToolAuditHookProjectionV1, AgentToolSettlementEventV1 } from "./AgentToolHooks";
 import { agentModelJson } from "./internal/AgentModelBinding";
 import { redactSensitive, type SensitiveRedactionOptions } from "../../library/redaction";
-import { AgentSetupError, AgentToolExecutionError, AgentToolPreCommitError } from "./errors";
+import { AgentSetupError, AgentToolExecutionError, AgentToolPreCommitError, ToolError } from "./errors";
+import type { Logger } from "../kernel/logging/Logger";
 import type { AgentRegistry, ToolDefinition } from "./AgentRegistry";
 import type { JsonObject, JsonValue, AgentToolCall, AgentToolResult } from "./semantic";
 import { agentToolCall, agentToolResult, normalizeJsonValue } from "./semantic";
@@ -430,6 +431,8 @@ export class AgentToolExecutor {
     private readonly services: ServiceProvider,
     private readonly registry: AgentRegistry,
     options: AgentToolExecutorOptions = {},
+    /** Where unexpected tool failures go with their stack; the model sees a generic message. */
+    private readonly logger?: Logger,
   ) {
     assertNonNegativeInteger(options.defaultTimeoutMs, "AgentToolExecutor.defaultTimeoutMs");
     assertPositiveInteger(options.scopeDisposeTimeoutMs, "AgentToolExecutor.scopeDisposeTimeoutMs");
@@ -1530,15 +1533,12 @@ export class AgentToolExecutor {
           );
         });
         const code = this.interruptionCode(error, tool, executionState);
+        if (code.endsWith("_OUTCOME_UNKNOWN")) {
+          this.logger?.error("Agent tool outcome unknown", { agent: agentName ?? null, tool: call.name, callId: call.id, code, phase: executionState.phase });
+        }
         return this.errorResult(call, code, executionState.timedOut ? "Tool execution timed out." : errorMessageOf(error), this.attemptMetadata(metadata, attempt), startedAt, { phase: executionState.phase });
       }
-      result = this.errorResult(
-        call,
-        "TOOL_EXECUTION_FAILED",
-        errorMessageOf(error),
-        this.attemptMetadata(metadata, attempt),
-        startedAt,
-      );
+      result = this.failedResult(call, agentName, "TOOL_EXECUTION_FAILED", error, "Tool execution failed.", this.attemptMetadata(metadata, attempt), startedAt);
     } finally {
       detach?.();
     }
@@ -1582,13 +1582,7 @@ export class AgentToolExecutor {
         ? await contributed[0]!.activation.activateAsync(scope)
         : await scope.resolveAsync(tool.target);
     } catch (error) {
-      return this.errorResult(
-        call,
-        "TOOL_RESOLVE_FAILED",
-        `Tool resolve failed: ${errorMessageOf(error)}`,
-        this.attemptMetadata(metadata, attempt),
-        startedAt,
-      );
+      return this.failedResult(call, agentName, "TOOL_RESOLVE_FAILED", error, "Tool could not be created.", this.attemptMetadata(metadata, attempt), startedAt);
     }
 
     if (signal.aborted) {
@@ -1638,12 +1632,14 @@ export class AgentToolExecutor {
       const explicitlyPreCommit = error instanceof AgentToolPreCommitError;
       const outcomeUnknown = !explicitlyPreCommit
         && (tool.metadata.sideEffect === "write" || tool.metadata.sideEffect === "external");
-      return this.errorResult(
+      return this.failedResult(
         call,
+        agentName,
         outcomeUnknown ? "TOOL_EXECUTION_FAILED_OUTCOME_UNKNOWN" : "TOOL_EXECUTION_FAILED",
+        error,
         outcomeUnknown
-          ? `Tool "${tool.metadata.name}" threw after side-effect execution started; retry safety is unknown: ${errorMessageOf(error)}`
-          : errorMessageOf(error),
+          ? `Tool "${tool.metadata.name}" threw after side-effect execution started; retry safety is unknown.`
+          : "Tool execution failed.",
         this.attemptMetadata(metadata, attempt),
         startedAt,
         outcomeUnknown ? { sideEffect: tool.metadata.sideEffect, phase: "execute" } : undefined,
@@ -1664,13 +1660,7 @@ export class AgentToolExecutor {
       return this.postExecutionOutcome(
         call,
         tool,
-        this.errorResult(
-          call,
-          "TOOL_OUTPUT_INVALID",
-          `Tool output processing failed: ${errorMessageOf(error)}`,
-          this.attemptMetadata(metadata, attempt),
-          startedAt,
-        ),
+        this.failedResult(call, agentName, "TOOL_OUTPUT_INVALID", error, "Tool output processing failed.", this.attemptMetadata(metadata, attempt), startedAt),
         metadata,
         startedAt,
         attempt,
@@ -1692,13 +1682,7 @@ export class AgentToolExecutor {
       return this.postExecutionOutcome(
         call,
         tool,
-        this.errorResult(
-          call,
-          "TOOL_RESULT_INVALID",
-          errorMessageOf(error),
-          this.attemptMetadata(metadata, attempt),
-          startedAt,
-        ),
+        this.failedResult(call, agentName, "TOOL_RESULT_INVALID", error, "Tool result is invalid.", this.attemptMetadata(metadata, attempt), startedAt),
         metadata,
         startedAt,
         attempt,
@@ -2056,6 +2040,27 @@ export class AgentToolExecutor {
   }
 
 
+  /**
+   * A tool's own failure: a ToolError message reaches the model as written;
+   * anything else is replaced by `fallback` and logged with its stack.
+   */
+  private failedResult(
+    call: AgentToolCall,
+    agentName: string | undefined,
+    code: string,
+    error: unknown,
+    fallback: string,
+    metadata: JsonObject,
+    startedAt: number,
+    details?: JsonObject,
+  ): AgentToolResult {
+    if (error instanceof ToolError) {
+      return this.errorResult(call, code, error.message, metadata, startedAt, details);
+    }
+    this.logger?.error("Agent tool failed", { agent: agentName ?? null, tool: call.name, callId: call.id, code, error: redactSensitive(error) });
+    return this.errorResult(call, code, fallback, metadata, startedAt, details);
+  }
+
   private errorResult(
     call: AgentToolCall,
     code: string,

package/core/agent/README.md

@@ -100,6 +100,14 @@ Tool input and output are validated by the model validator
 otherwise. Audit entries redact `input`, `result` and execution `metadata`
 by default using `bazis/library/redaction`.
 
+A tool reports a failure to the model with `throw new ToolError("Product
+kiwi is no longer sold")`: the message reaches the model as written. Any other
+exception from `execute` reaches the model as `Tool execution failed.` — internal
+details stay out of the LLM — and goes to the application log with its stack
+(`Agent tool failed`). Failures of the model itself are logged as `Agent model
+call failed`. The LLM connectors pass the application logger; a runtime created
+by hand takes `options.logger`.
+
 Retries are opt-in. `write` and `external` tools need an idempotency key before
 the executor repeats them. Runtime-generated keys include both the invocation id
 and the unique model call id; `toolExecution.idempotencyKeyForCall` gives a

package/core/agent/errors.ts

@@ -22,12 +22,25 @@ export class AgentToolExecutionError extends Error {
   }
 }
 
+/**
+ * A failure a tool reports to the model on purpose: the message reaches the
+ * model as written, so the model can explain it or try another way. Any other
+ * exception from `execute` reaches the model as "Tool execution failed." and
+ * goes to the application log with its stack.
+ */
+export class ToolError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "ToolError";
+  }
+}
+
 /**
  * Explicit assertion by a tool that execution failed before any side effect
  * could commit. Only this typed error keeps write/external failures eligible
- * for an idempotency-gated retry.
+ * for an idempotency-gated retry. Its message reaches the model like a ToolError.
  */
-export class AgentToolPreCommitError extends Error {
+export class AgentToolPreCommitError extends ToolError {
   constructor(message: string) {
     super(message);
     this.name = "AgentToolPreCommitError";

package/core/agent/index.ts

@@ -15,6 +15,7 @@ export {
   AgentSetupError,
   AgentToolExecutionError,
   AgentToolPreCommitError,
+  ToolError,
 } from "./errors";
 export {
   AGENT_RUNTIME_OPTIONS,

package/core/agent/internal/AgentExecutionDriver.ts

@@ -3,6 +3,7 @@ import { describeTool } from "../Tool.contract";
 import type { ServiceProvider } from "../../di";
 import { getGeneratedOpenApiMetadata } from "../../http/OpenApi/generatedOpenApiRegistry";
 import { redactSensitive, redactSensitiveText } from "../../../library/redaction";
+import type { Logger } from "../../kernel/logging/Logger";
 import { AgentRuntimeError } from "../errors";
 import { validateAgentJsonSchema } from "./AgentJsonSchema";
 import type { AgentDefinition, AgentRegistry } from "../AgentRegistry";
@@ -80,6 +81,11 @@ export interface AgentRuntimeOptions {
   readonly contextBuilder?: AgentContextBuilder;
   readonly contextLimits?: AgentContextLimits;
   readonly toolExecutorOptions?: AgentToolExecutorOptions;
+  /**
+   * Where failures of the model and unexpected tool failures go, with their
+   * stack. The LLM connectors pass the application logger.
+   */
+  readonly logger?: Logger;
 }
 
 export interface AgentRuntimeInvokeOptions {
@@ -503,6 +509,7 @@ export class AgentExecutionDriver {
   readonly defaultTimeoutMs?: number;
   private readonly defaultContextLimits?: AgentContextLimits;
   private readonly contextBuilder: AgentContextBuilder;
+  private readonly logger?: Logger;
 
   constructor(
     services: ServiceProvider,
@@ -521,7 +528,8 @@ export class AgentExecutionDriver {
       : options.timeoutMs ?? DEFAULT_MODEL_TIMEOUT_MS;
     this.defaultContextLimits = normalizeAgentContextLimits(options.contextLimits, "AgentRuntime.contextLimits");
     this.contextBuilder = options.contextBuilder ?? new DefaultAgentContextBuilder();
-    this.toolExecutor = new AgentToolExecutor(services, registry, options.toolExecutorOptions);
+    this.logger = options.logger;
+    this.toolExecutor = new AgentToolExecutor(services, registry, options.toolExecutorOptions, options.logger);
   }
 
   async invoke(agentName: string, options: AgentRuntimeInvokeOptions = {}): Promise<AgentRuntimeResult> {
@@ -1122,6 +1130,7 @@ export class AgentExecutionDriver {
       try {
         return { ok: true, value: normalizeProviderResponse(rawResponse) };
       } catch (error) {
+        this.logger?.error("Agent model call failed", { agent: agentName, invocationId: request.invocationId, code: "AGENT_PROVIDER_RESPONSE_INVALID", error: redactSensitive(error) });
         return {
           ok: false,
           error: runtimeError("AGENT_PROVIDER_RESPONSE_INVALID", `Model provider returned an invalid response: ${errorMessageOf(error)}`),
@@ -1133,6 +1142,9 @@ export class AgentExecutionDriver {
         : error instanceof AgentRuntimeAbortError
           ? "AGENT_ABORTED"
           : "AGENT_PROVIDER_FAILED";
+      if (code !== "AGENT_ABORTED") {
+        this.logger?.error("Agent model call failed", { agent: agentName, invocationId: request.invocationId, code, error: redactSensitive(error) });
+      }
       return { ok: false, error: runtimeError(code, errorMessageOf(error)) };
     } finally {
       acceptingText = false;

package/core/infra/connectors/codex/CodexAppServerClient.ts

@@ -232,7 +232,7 @@ export class CodexAppServerClient implements CodexClient {
         if (method === "account/updated") this.modelCache = undefined;
       }, () => { this.clearLogin(); this.modelCache = undefined; });
       const initialized = await client.request("initialize", {
-        clientInfo: { name: "bazis", title: "Bazis", version: "0.99.1" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.99.2" }, capabilities: { experimentalApi: true },
       }, 15_000, signal);
       if (resolve(text(initialized.codexHome, 4096)) !== this.paths.home) throw new CodexError("PROTOCOL_ERROR");
       client.notify("initialized");

package/core/infra/connectors/llm.ts

@@ -1,6 +1,7 @@
 import type { AppConfig, ConfigRegistry, Secret } from "../../kernel";
 import { AGENT_MODEL_PROVIDER, AGENT_RUNTIME_OPTIONS, AgentRuntime, type AgentModelProvider } from "../../agent";
 import { DI, SERVICE_PROVIDER, type ProviderDefinition } from "../../di";
+import { LOGGER } from "../../kernel/logging/Logger";
 import { reader, requireValue } from "../connectorConfig";
 import { InfraError, type InfraConnector } from "../InfraConnector";
 import { identifyConnector } from "../connectorIdentity";
@@ -62,7 +63,8 @@ export function resolveLlmConnectionOptions<T extends LlmConfigShape>(
 export const agentRuntimeProviders: readonly ProviderDefinition[] = Object.freeze([
   DI.singleton(DI.factoryProviderWithResolver(AgentRuntime, [AGENT_MODEL_PROVIDER], (resolver, model: AgentModelProvider) => {
     const services = resolver.resolve(SERVICE_PROVIDER);
-    return new AgentRuntime(services, model, services.has(AGENT_RUNTIME_OPTIONS) ? services.resolve(AGENT_RUNTIME_OPTIONS) : {});
+    const options = services.has(AGENT_RUNTIME_OPTIONS) ? services.resolve(AGENT_RUNTIME_OPTIONS) : {};
+    return new AgentRuntime(services, model, { ...options, logger: options.logger ?? services.tryResolve(LOGGER) });
   })),
 ]);
 

package/index.ts

@@ -83,6 +83,7 @@ export {
   AgentRuntimeError,
   AgentSemanticError,
   AgentToolExecutionError,
+  ToolError,
   ApproximateAgentContextTokenEstimator,
   DefaultAgentContextBuilder,
   Tool,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.99.1",
+  "version": "0.99.2",
   "description": "Modular backend framework for Bun in TypeScript: DI wired by codegen, HTTP, a PostgreSQL ORM, JWT, WebSocket, agents and a CLI.",
   "license": "MIT",
   "author": "Alexander Alenin",