bazis 0.100.4 → 0.100.6

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.100.4" }, capabilities: { experimentalApi: true },
+        clientInfo: { name: "bazis", title: "Bazis", version: "0.100.6" }, 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

@@ -31,7 +31,11 @@ export interface LlmConnectorOptions {
   /**
    * Check the provider at start (the adapter's `connect`: `GET /models` for an
    * OpenAI-compatible API, five seconds), so a wrong key or address stops the
-   * start instead of the first agent request. Default `true`.
+   * start instead of the first agent request. By default it runs in
+   * development and production and not in the `test` environment, where a
+   * test replaces the model; `true` checks there too, `false` never checks.
+   * The same choice applies to `/health`: in tests `infra:llm` does not call
+   * the provider and reports healthy.
    */
   readonly checkOnStart?: boolean;
 }
@@ -92,7 +96,7 @@ export function llmConnect<T extends LlmConfigShape>(
   adapter: LlmProviderAdapter,
   options: LlmConnectorOptions = {},
 ): InfraConnector<AgentModelProvider> {
-  const described = new WeakMap<AgentModelProvider, { connection: LlmConnectionOptions; settings: string[] }>();
+  const described = new WeakMap<AgentModelProvider, { connection: LlmConnectionOptions; settings: string[]; check: boolean; offline: boolean }>();
   return identifyConnector({
     token: AGENT_MODEL_PROVIDER,
     config,
@@ -101,11 +105,16 @@ export function llmConnect<T extends LlmConfigShape>(
     create(configs) {
       const connection = resolveLlmConnectionOptions(config, options, configs);
       const provider = adapter.create(connection);
-      described.set(provider, { connection, settings: settingNames(config, configs, ["baseUrl", "apiKey"]) });
+      // The environment of this kernel's configuration: tests do not call the real provider.
+      const environment = (configs?.get(config) as { environment?: string } | undefined)?.environment;
+      const check = options.checkOnStart ?? environment !== "test";
+      // In tests the provider is not reached at all, unless checkOnStart: true asks for it.
+      const offline = environment === "test" && options.checkOnStart !== true;
+      described.set(provider, { connection, settings: settingNames(config, configs, ["baseUrl", "apiKey"]), check, offline });
       return provider;
     },
     connect(provider, signal) {
-      if (options.checkOnStart === false) return;
+      if (described.get(provider)?.check === false || options.checkOnStart === false) return;
       return adapter.connect?.(provider, signal);
     },
     describe(provider, { connected }) {
@@ -114,15 +123,16 @@ export function llmConnect<T extends LlmConfigShape>(
       return {
         kind: `${known.connection.provider} · ${known.connection.model}`,
         address: known.connection.baseUrl,
-        details: connected && options.checkOnStart !== false && adapter.connect !== undefined ? ["checked"] : [],
+        details: connected && known.check && adapter.connect !== undefined ? ["checked"] : [],
         settings: known.settings,
       };
     },
     dispose(provider) {
       return adapter.dispose?.(provider);
     },
+    // Like the start check: a test does not reach the real provider.
     healthCheck: adapter.healthCheck
-      ? (provider, signal) => adapter.healthCheck?.(provider, signal) ?? false
+      ? (provider, signal) => described.get(provider)?.offline === true || (adapter.healthCheck?.(provider, signal) ?? false)
       : undefined,
   }, "llm");
 }

package/core/websocket/adapter/redis-delivery-store.ts

@@ -14,6 +14,14 @@ export interface RedisReliableDeliveryOptions {
   readonly maxReadBytes?: number;
 }
 
+/** Redis settings without which an acknowledged write may be lost. */
+const DURABLE_REDIS: Readonly<Record<string, string>> = Object.freeze({
+  appendonly: "yes",
+  appendfsync: "always",
+  "no-appendfsync-on-rewrite": "no",
+  "maxmemory-policy": "noeviction",
+});
+
 export class RedisRoomDeliveryStore implements ReliableRoomDelivery {
   private readonly limits: Required<Omit<RedisReliableDeliveryOptions, "requireAof">>;
   private readonly requireAof: boolean;
@@ -47,9 +55,18 @@ export class RedisRoomDeliveryStore implements ReliableRoomDelivery {
     if (Array.isArray(settings)) for (let i = 0; i < settings.length; i += 2) values.set(settings[i]!, settings[i + 1]!);
     else for (const [key, value] of Object.entries(settings)) values.set(key, value);
     const info = await this.operations.send("INFO", ["persistence"]) as string;
-    if (values.get("appendonly") !== "yes" || values.get("appendfsync") !== "always" || values.get("maxmemory-policy") !== "noeviction"
-      || values.get("no-appendfsync-on-rewrite") !== "no"
-      || !info.includes("aof_last_write_status:ok") || !info.includes("loading:0")) throw new WebSocketDeliveryError("DURABILITY_CONFIGURATION");
+    const problems = Object.entries(DURABLE_REDIS)
+      .filter(([name, needed]) => values.get(name) !== needed)
+      .map(([name, needed]) => `${name} is ${values.get(name) ?? "unknown"}, needs ${needed}`);
+    if (!info.includes("aof_last_write_status:ok")) problems.push("the last append-only file write failed (aof_last_write_status)");
+    if (!info.includes("loading:0")) problems.push("Redis is still loading its data");
+    if (problems.length > 0) {
+      throw new WebSocketDeliveryError(
+        "DURABILITY_CONFIGURATION",
+        `WebSocket delivery needs a Redis that does not lose writes: ${problems.join("; ")}. `
+          + "Set them in redis.conf or with CONFIG SET; otherwise undelivered messages and sessions may be lost.",
+      );
+    }
   }
 
   async publish(request: ReliableRoomPublication): Promise<ReliableBroadcastReceipt> {

package/package.json

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