bazis 0.110.1 → 0.111.1

package/core/agent/AgentToolExecutor.ts

@@ -853,21 +853,6 @@ export class AgentToolExecutor {
       return this.finish(call, result, startedAt, metadata, options, audit, undefined, undefined, undefined, executionState);
     }
 
-    if (
-      (tool.metadata.sideEffect === "write" || tool.metadata.sideEffect === "external")
-      && audit.sink === undefined
-      && !(options.allowUnauditedSideEffects ?? this.allowUnauditedSideEffects)
-    ) {
-      const result = this.errorResult(
-        call,
-        "TOOL_AUDIT_REQUIRED",
-        `Tool "${tool.metadata.name}" has side effects and requires an audit sink.`,
-        metadata,
-        startedAt,
-      );
-      return this.finish(call, result, startedAt, metadata, options, audit, tool, options.agentName, undefined, executionState);
-    }
-
     const visibility = this.authorizeAgent(tool, options);
     if (!visibility.allowed) {
       const code = visibility.code ?? "TOOL_NOT_VISIBLE_TO_AGENT";
@@ -887,6 +872,22 @@ export class AgentToolExecutor {
       return this.finish(call, result, startedAt, metadata, options, audit, tool, options.agentName, undefined, executionState);
     }
 
+    // After visibility: a tool the agent cannot see is refused for that reason.
+    if (
+      (tool.metadata.sideEffect === "write" || tool.metadata.sideEffect === "external")
+      && audit.sink === undefined
+      && !(options.allowUnauditedSideEffects ?? this.allowUnauditedSideEffects)
+    ) {
+      const result = this.errorResult(
+        call,
+        "TOOL_AUDIT_REQUIRED",
+        `Tool "${tool.metadata.name}" has side effects and requires an audit sink.`,
+        metadata,
+        startedAt,
+      );
+      return this.finish(call, result, startedAt, metadata, options, audit, tool, options.agentName, undefined, executionState);
+    }
+
     const schema = this.schemaSettings(options);
     const schemaGate = this.ensureSchemaValidator(call, tool, schema, metadata, startedAt);
     if (schemaGate) {

package/core/app/runApp.ts

@@ -6,10 +6,12 @@ import {
   Global,
   Module,
   singletonValue,
+  CLASS_PROVIDER_HOOK,
   type BazisModuleRef,
 } from "../di";
 import { loadBazisGeneratedRuntime } from "../generatedRuntime";
 import { missingCacheModuleCheck } from "../cache/http/missingCacheModuleCheck";
+import { cacheableClassProviderHook } from "../cache/di/classProviderHook";
 import { httpModule, useModelValidator, type HttpModuleOptions, type ModelValidator } from "../http";
 import { grpcModule, type GrpcModuleOptions } from "../grpc";
 import { buildHttpOpenApiDocument } from "../http/OpenApi/openApiDocument";
@@ -322,6 +324,11 @@ export function composeApp(root: BazisModuleRef, options: RunAppOptions = {}): B
     // Warns about @OutputCache routes when no cache module is installed.
     globals.push({ global: true, providers: [missingCacheModuleCheck()] });
   }
+  // The cache wrapper of @Cacheable / @CacheableRedis classes, also without a cache
+  // module: it then needs ICache, and the graph check names the class and says to add
+  // cache: memory(). Without it the decorators would silently do nothing. The cache
+  // module registers the same hook, and DI keeps one.
+  globals.push({ global: true, providers: [singletonValue(CLASS_PROVIDER_HOOK, cacheableClassProviderHook)] });
   const appRoot: BazisModuleRef =
     globals.length > 0 || options.config !== undefined
       ? {

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.110.1" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.111.1" }, 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/llmRouter.ts

@@ -12,6 +12,7 @@ import {
   type AgentModelResponse,
 } from "../../agent";
 import { InfraError, type InfraConnector } from "../InfraConnector";
+import { identifyConnector } from "../connectorIdentity";
 import { redactSensitiveText } from "../../../library/redaction";
 import { awaitAbortable } from "../../kernel/internal/awaitAbortable";
 import {
@@ -426,7 +427,9 @@ export function llmRouter(
   ensureFallbacksValid(entries);
   const configs = Object.freeze(Array.from(new Set(entries.map(([, profile]) => profile.config))));
 
-  return {
+  // The framework LLM connector, like llmConnect: it never touches the schema,
+  // so it may start before application services next to ormBazis ensureCreated.
+  return identifyConnector({
     token: AGENT_MODEL_PROVIDER,
     config: configs,
     providers: agentRuntimeProviders,
@@ -462,5 +465,5 @@ export function llmRouter(
     healthCheck(client, signal) {
       return client instanceof LlmModelRouter ? client.healthCheck(signal) : false;
     },
-  };
+  }, "llm");
 }

package/core/infra/connectors/openaiCompatible.ts

@@ -467,12 +467,11 @@ export class OpenAiCompatibleModelProvider implements AgentModelProvider {
         const toolCalls = message.content
           .filter((part) => part.kind === "tool-call")
           .map((part) => {
-            const providerName = mapping.bazisToProvider.get(part.call.name);
-            if (providerName === undefined) {
-              throw new OpenAiCompatibleProviderError(
-                `Assistant transcript references tool "${part.call.name}" which is absent from the request contract.`,
-              );
-            }
+            // A call to a tool outside this request (one the agent may not use, or
+            // a made-up name) stays in the history next to its denial: the model must
+            // see both to recover. It gets a wire name that no request tool uses.
+            const providerName = mapping.bazisToProvider.get(part.call.name)
+              ?? providerToolName(part.call.name, new Set(mapping.providerToBazis.keys()));
             return Object.freeze({
               id: part.call.id,
               type: "function" as const,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.110.1",
+  "version": "0.111.1",
   "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",