bazis 0.99.4 → 0.99.6

package/core/agent/AgentRuntime.ts

@@ -1,5 +1,6 @@
 import { createToken, type ServiceProvider } from "../di";
 import { modelValidatorAdapter } from "../../library/validation";
+import { AgentSetupError } from "./errors";
 import type { AgentDataDefinition } from "./AgentDataDefinition";
 import { AgentRegistry, type ToolDefinition } from "./AgentRegistry";
 import {
@@ -62,6 +63,15 @@ export class AgentRuntime {
     return this.catalog.listTools();
   }
 
+  /** A profile the model provider does not serve fails before the model is called. */
+  private assertModelProfile(agentName: string, profile: string | undefined): void {
+    if (profile === undefined || typeof this.modelProvider.modelProfiles !== "function") return;
+    const configured = this.modelProvider.modelProfiles();
+    if (!configured.includes(profile)) {
+      throw new AgentSetupError(`Agent "${agentName}": model profile "${profile}" is not configured (configured: ${[...configured].sort().join(", ")}).`);
+    }
+  }
+
   /**
    * Checks a definition the way `run` does, without calling the model: an
    * invalid field or a tool name not registered in `@Module.tools` throws
@@ -69,6 +79,7 @@ export class AgentRuntime {
    */
   check(definition: AgentDataDefinition): void {
     AgentRegistry.fromDefinition(definition, this.catalog.listTools());
+    this.assertModelProfile(definition.name, definition.modelProfile);
   }
 
   /**
@@ -78,6 +89,7 @@ export class AgentRuntime {
    */
   async run(definition: AgentDataDefinition, options: AgentRuntimeInvokeOptions = {}): Promise<AgentRuntimeResult> {
     const registry = AgentRegistry.fromDefinition(definition, this.catalog.listTools());
+    this.assertModelProfile(definition.name, options.modelProfile ?? definition.modelProfile);
     const driver = new AgentExecutionDriver(this.services, registry, this.modelProvider, this.options);
     return driver.invoke(definition.name, options);
   }

package/core/agent/ModelProvider.ts

@@ -16,6 +16,12 @@ export interface AgentModelProvider {
     request: AgentModelRequest,
     context: AgentModelProviderContext,
   ): AgentModelResponse | Promise<AgentModelResponse>;
+  /**
+   * Model profiles this provider serves, when it routes by profile
+   * (`llmRouter`). AgentRuntime rejects an agent naming another profile before
+   * the model is called. Without it any profile is passed through.
+   */
+  modelProfiles?(): readonly string[];
 }
 
 export const AGENT_MODEL_PROVIDER = createToken<AgentModelProvider>("AgentModelProvider");

package/core/agent/README.md

@@ -143,6 +143,11 @@ await this.agents.run(support, {
 conversation message when trimming old history. Provider requests include
 `metadata.agentContext.trace` so context assembly is inspectable.
 
+With `llmRouter`, `check` and `run` reject a `modelProfile` the router does
+not serve; a fallback to another profile is logged as `LLM model profile
+failed, using fallback`. A model provider that gives up after its own deadline
+throws `AgentModelTimeoutError`, and the run reports `AGENT_PROVIDER_TIMEOUT`.
+
 LLM clients are registered by infra connectors. Agents name a model profile;
 infra owns provider URLs, model ids, limits and fallback:
 

package/core/agent/errors.ts

@@ -47,6 +47,17 @@ export class AgentToolPreCommitError extends ToolError {
   }
 }
 
+/**
+ * A model provider gave up on a request after its own deadline (for example
+ * the connector's `timeoutMs`). The run reports it as AGENT_PROVIDER_TIMEOUT.
+ */
+export class AgentModelTimeoutError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AgentModelTimeoutError";
+  }
+}
+
 /** Error thrown when the agent runtime is configured incorrectly. */
 export class AgentRuntimeError extends Error {
   constructor(message: string) {

package/core/agent/index.ts

@@ -14,6 +14,7 @@ export {
   AgentSemanticError,
   AgentSetupError,
   AgentToolExecutionError,
+  AgentModelTimeoutError,
   AgentToolPreCommitError,
   ToolError,
 } from "./errors";

package/core/agent/internal/AgentExecutionDriver.ts

@@ -4,7 +4,7 @@ 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 { AgentModelTimeoutError, AgentRuntimeError } from "../errors";
 import { validateAgentJsonSchema } from "./AgentJsonSchema";
 import type { AgentDefinition, AgentRegistry } from "../AgentRegistry";
 import {
@@ -1137,7 +1137,7 @@ export class AgentExecutionDriver {
         };
       }
     } catch (error) {
-      const code = error instanceof AgentRuntimeTimeoutError
+      const code = error instanceof AgentRuntimeTimeoutError || error instanceof AgentModelTimeoutError
         ? "AGENT_PROVIDER_TIMEOUT"
         : error instanceof AgentRuntimeAbortError
           ? "AGENT_ABORTED"

package/core/di/extensions/hosted-service.ts

@@ -38,6 +38,8 @@ export interface HostedService {
   readonly planValidator?: HostedServicePlanValidator;
   /** Receives the application logger before start, when one is registered. */
   useDiagnostics?(diagnostics: HostedServiceDiagnostics): void;
+  /** Name in startup diagnostics, such as `infra:db`; the class name by default. */
+  readonly diagnosticName?: string;
   start(signal?: AbortSignal): void | Promise<void>;
   stop(): void | Promise<void>;
   /**

package/core/infra/InfraLifecycle.ts

@@ -1,4 +1,4 @@
-import type { HostedService } from "../di";
+import type { HostedService, HostedServiceDiagnostics } from "../di";
 import { InfraError, type InfraConnector } from "./InfraConnector";
 import { bindConnectorLifecycle } from "./connectorIdentity";
 import { awaitAbortable } from "../kernel/internal/awaitAbortable";
@@ -17,11 +17,14 @@ const DEFAULT_INFRA_PHASE = -100;
  */
 export class InfraLifecycle<TClient> implements HostedService {
   public readonly phase: number;
+  /** The manifest key, as in `/health`: `infra:db`. */
+  public readonly diagnosticName: string;
   private client?: TClient;
   private created = false;
   private disposed = false;
   private startPromise?: Promise<void>;
   private disposePromise?: Promise<void>;
+  private diagnostics?: HostedServiceDiagnostics;
 
   public constructor(
     private readonly name: string,
@@ -32,6 +35,7 @@ export class InfraLifecycle<TClient> implements HostedService {
     this.client = client;
     this.created = client !== undefined;
     this.phase = connector.phase ?? DEFAULT_INFRA_PHASE;
+    this.diagnosticName = `infra:${name}`;
     bindConnectorLifecycle(connector, this);
   }
 
@@ -40,10 +44,22 @@ export class InfraLifecycle<TClient> implements HostedService {
     if (!this.created) {
       this.client = this.connector.create(this.configs);
       this.created = true;
+      this.forwardDiagnostics();
     }
     return this.client as TClient;
   }
 
+  /** The application logger reaches a client that reports on its own, such as `llmRouter` falling back. */
+  public useDiagnostics(diagnostics: HostedServiceDiagnostics): void {
+    this.diagnostics = diagnostics;
+    if (this.created) this.forwardDiagnostics();
+  }
+
+  private forwardDiagnostics(): void {
+    const client = this.client as { useDiagnostics?: (diagnostics: HostedServiceDiagnostics) => void } | undefined;
+    if (this.diagnostics !== undefined && typeof client?.useDiagnostics === "function") client.useDiagnostics(this.diagnostics);
+  }
+
   public start(signal?: AbortSignal): Promise<void> {
     this.startPromise ??= Promise.resolve().then(() => this.connect(signal));
     return this.startPromise;

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

@@ -1,6 +1,9 @@
 import type { AppConfig } from "../../kernel";
+import type { HostedServiceDiagnostics } from "../../di";
+import { redactSensitive } from "../../../library/redaction";
 import {
   AGENT_MODEL_PROVIDER,
+  AgentModelTimeoutError,
   AgentRuntime,
   agentModelRequest,
   type AgentModelProvider,
@@ -194,11 +197,13 @@ export class LlmModelRouter implements AgentModelProvider {
   private initializePromise?: Promise<void>;
   private disposePromise?: Promise<void>;
   private disposed = false;
+  private diagnostics?: HostedServiceDiagnostics;
 
   public constructor(
     profiles: readonly RuntimeProfile[],
     private readonly defaultProfile: string,
     private readonly factories: readonly (() => RuntimeProfile)[] = [],
+    private readonly profileNames: readonly string[] = profiles.map((profile) => profile.name),
   ) {
     for (let index = 0; index < profiles.length; index += 1) {
       const profile = profiles[index] as RuntimeProfile;
@@ -213,6 +218,16 @@ export class LlmModelRouter implements AgentModelProvider {
     return this.completeWithProfile(request, context, requested, new Set<string>());
   }
 
+  /** Profile names an agent may use in `modelProfile`. */
+  public modelProfiles(): readonly string[] {
+    return this.profileNames;
+  }
+
+  /** The application logger: a fallback is reported, not silent. */
+  public useDiagnostics(diagnostics: HostedServiceDiagnostics): void {
+    this.diagnostics = diagnostics;
+  }
+
   public connect(signal?: AbortSignal): Promise<void> {
     if (this.disposed) {
       return Promise.reject(new InfraError("LLM model router is already disposed."));
@@ -363,11 +378,15 @@ export class LlmModelRouter implements AgentModelProvider {
       // A second model must not silently append a new answer to already visible text.
       if (fallback !== undefined && !emittedText) {
         if (context.signal.aborted) throw new LlmModelRouterError("LLM model request was cancelled before provider dispatch.");
+        this.diagnostics?.warn("LLM model profile failed, using fallback", {
+          profile: profileName, fallback, agent: context.agentName, invocationId: context.invocationId, error: redactSensitive(error),
+        });
         return this.completeWithProfile(request, context, fallback, visited);
       }
-      throw new LlmModelRouterError(
-        `LLM model profile "${profileName}" failed: ${errorMessageOf(error)}`,
-      );
+      const message = `LLM model profile "${profileName}" failed: ${errorMessageOf(error)}`;
+      // Keep a timeout a timeout: the run reports it as AGENT_PROVIDER_TIMEOUT.
+      if (error instanceof AgentModelTimeoutError) throw new AgentModelTimeoutError(message);
+      throw new LlmModelRouterError(message);
     } finally {
       acceptingText = false;
     }
@@ -432,7 +451,7 @@ export function llmRouter(
           options: profile.options,
         });
       });
-      return new LlmModelRouter([], defaultProfile, factories);
+      return new LlmModelRouter([], defaultProfile, factories, entries.map(([name]) => name));
     },
     connect(client, signal) {
       return client instanceof LlmModelRouter ? client.connect(signal) : undefined;

package/core/infra/connectors/openaiCompatible.ts

@@ -1,4 +1,5 @@
 import {
+  AgentModelTimeoutError,
   agentMessage,
   agentModelResponse,
   agentToolCall,
@@ -490,7 +491,7 @@ export class OpenAiCompatibleModelProvider implements AgentModelProvider {
     const detach = attachAbortForwarding(signal ? AbortSignal.any([signal, this.lifetime.signal]) : this.lifetime.signal, abort);
     const timeout = this.requestTimeoutMs === undefined
       ? undefined
-      : setTimeout(() => abort.abort(new Error("OpenAI-compatible request timed out.")), this.requestTimeoutMs);
+      : setTimeout(() => abort.abort(new AgentModelTimeoutError("OpenAI-compatible request timed out.")), this.requestTimeoutMs);
     try {
       abort.signal.throwIfAborted();
       const response = await this.fetcher(`${this.baseUrl}${path}`, {

package/core/infra/connectors/opensearch.ts

@@ -134,8 +134,12 @@ export class OpenSearchClient {
   }
 }
 
-/** OpenSearch client token for injection into application services. */
-export const OPENSEARCH: InjectionToken<OpenSearchClient> = createToken<OpenSearchClient>("OpenSearch");
+/**
+ * OpenSearch client of the `openSearchConnect()` connector, injected by type:
+ * `constructor(private readonly search: IOpenSearch)`.
+ */
+export interface IOpenSearch extends OpenSearchClient {}
+export const IOpenSearch = createToken<IOpenSearch>("IOpenSearch") as InjectionToken<OpenSearchClient>;
 
 /**
  * Config interface required by the OpenSearch connector. The search subsystem
@@ -278,7 +282,7 @@ async function readBoundedText(response: Response, maxBytes: number, label: stri
  * });
  * @Infra({ search: openSearchConnect(searchConfig) })
  * export class AppInfra {}
- * // injection by token: scoped(ISearchService, SearchService, [OPENSEARCH] as const)
+ * // by type: class SearchService { constructor(private readonly search: IOpenSearch) {} }
  * ```
  */
 export function openSearchConnect<T extends OpenSearchConfigShape>(
@@ -286,7 +290,7 @@ export function openSearchConnect<T extends OpenSearchConfigShape>(
   options: OpenSearchConnectorOptions = {},
 ): InfraConnector<OpenSearchClient> {
   return {
-    token: options.token ?? OPENSEARCH,
+    token: options.token ?? IOpenSearch,
     config,
     create(configs) {
       return new OpenSearchClient(buildOpenSearchOptions(config, options, configs));

package/core/infra/connectors/postgres.ts

@@ -4,8 +4,13 @@ import type { AppConfig, ConfigRegistry, Secret } from "../../kernel";
 import { reader, requireValue } from "../connectorConfig";
 import { errorMessage, InfraError, type InfraConnector } from "../InfraConnector";
 
-/** PostgreSQL client (native Bun `SQL`, no external dependencies). */
-export const POSTGRES: InjectionToken<SQL> = createToken<SQL>("Postgres");
+/**
+ * PostgreSQL client (native Bun `SQL`, no external dependencies) of the
+ * `postgres()` connector, injected by type:
+ * `constructor(private readonly sql: IPostgres)`.
+ */
+export interface IPostgres extends SQL {}
+export const IPostgres = createToken<IPostgres>("IPostgres") as InjectionToken<SQL>;
 
 /**
  * Config interface required by the PostgreSQL connector. The database subsystem
@@ -69,7 +74,7 @@ export function postgresConnectionOptions(config: AppConfig<PostgresConfigShape>
  * });
  * @Infra({ db: postgres(dbConfig) })
  * export class AppInfra {}
- * // injection by token: scoped(IReportsService, ReportsService, [POSTGRES] as const)
+ * // by type: class ReportsService { constructor(private readonly sql: IPostgres) {} }
  * ```
  */
 export function postgres<T extends PostgresConfigShape>(config: AppConfig<T>, options: PostgresConnectorOptions = {}): InfraConnector<SQL> {
@@ -78,7 +83,7 @@ export function postgres<T extends PostgresConfigShape>(config: AppConfig<T>, op
     throw new InfraError("postgres shutdownTimeoutMs must be an integer 0..2147483647");
   }
   return {
-    token: options.token ?? POSTGRES,
+    token: options.token ?? IPostgres,
     config,
     create(configs) {
       return new SQL(postgresConnectionOptions(config, configs));

package/core/infra/connectors/redis.ts

@@ -11,9 +11,17 @@ import type { AppConfig, Secret } from "../../kernel";
 import { RedisDistributedCacheBackend, type RedisDistributedCacheTuning } from "../cache/RedisDistributedCacheBackend";
 import { reader, requireValue } from "../connectorConfig";
 import { errorMessage, InfraError, type InfraConnector } from "../InfraConnector";
+import { redactSensitiveText } from "../../../library/redaction";
 
-/** Redis/Valkey client (native Bun `RedisClient`, no external dependencies). */
-export const REDIS: InjectionToken<RedisClient> = createToken<RedisClient>("Redis");
+const DEFAULT_REDIS_CONNECT_TIMEOUT_MS = 5_000;
+
+/**
+ * Redis/Valkey client (native Bun `RedisClient`, no external dependencies) of
+ * the `redisConnect()` connector, injected by type:
+ * `constructor(private readonly redis: IRedis)`.
+ */
+export interface IRedis extends RedisClient {}
+export const IRedis = createToken<IRedis>("IRedis") as InjectionToken<RedisClient>;
 
 /**
  * Config interface required by the Redis connector. The subsystem config
@@ -30,6 +38,12 @@ export type RedisConnectorCacheMode =
 
 export interface RedisConnectorOptions {
   readonly token?: InjectionToken<RedisClient>;
+  /**
+   * How long the start waits for the first connection, ms (default 5000).
+   * The Bun client keeps retrying a refused connection; without a bound an
+   * unreachable Redis held the whole start until its timeout.
+   */
+  readonly connectTimeoutMs?: number;
   /**
    * Publishes a distributed cache backend on top of the client: `{ cache: "distributed" }`.
    * For fine tuning use `{ cache: { mode: "distributed", keyPrefix, ... } }`.
@@ -81,7 +95,7 @@ function distributedCacheProviders(tuning: RedisDistributedCacheTuning, token: I
  * export const redisConfig = defineConfig("redis", { default: { url: "redis://localhost:6379" } });
  * @Infra({ cache: redisConnect(redisConfig, { cache: "distributed" }) })
  * export class AppInfra {}
- * // injection by token: scoped(ISessionsService, SessionsService, [REDIS] as const)
+ * // by type: class SessionsService { constructor(private readonly redis: IRedis) {} }
  * ```
  */
 export function redisConnect<T extends RedisConfigShape>(
@@ -89,7 +103,12 @@ export function redisConnect<T extends RedisConfigShape>(
   options: RedisConnectorOptions = {},
 ): InfraConnector<RedisClient> {
   const cache = options.cache;
-  const token = options.token ?? REDIS;
+  const token = options.token ?? IRedis;
+  const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_REDIS_CONNECT_TIMEOUT_MS;
+  if (!Number.isSafeInteger(connectTimeoutMs) || connectTimeoutMs <= 0) {
+    throw new InfraError("redisConnect connectTimeoutMs must be a positive integer.");
+  }
+  const urls = new WeakMap<RedisClient, string>();
   const cacheProviders =
     cache === undefined
       ? undefined
@@ -101,13 +120,28 @@ export function redisConnect<T extends RedisConfigShape>(
     providers: cacheProviders,
     exports: cacheProviders ? [DISTRIBUTED_CACHE_BACKEND, DISTRIBUTED_OUTPUT_CACHE, DISTRIBUTED_SERVICE_CACHE, IDistributedCache] : undefined,
     create(configs) {
-      return new RedisClient(redisUrl(reader(config, configs).get("url")));
+      const url = redisUrl(reader(config, configs).get("url"));
+      const client = new RedisClient(url);
+      urls.set(client, url);
+      return client;
     },
     async connect(client) {
+      // The address without a password: it names the server in the error.
+      const target = redactSensitiveText(urls.get(client) ?? "redis");
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      const deadline = new Promise<never>((_resolve, reject) => {
+        timer = setTimeout(() => reject(new InfraError(`Infra connector "redis": failed to connect to ${target} within ${connectTimeoutMs} ms.`)), connectTimeoutMs);
+      });
       try {
-        await client.connect();
+        await Promise.race([client.connect(), deadline]);
       } catch (error) {
-        throw new InfraError(`Infra connector "redis": failed to connect — ${errorMessage(error)}`);
+        if (error instanceof InfraError) {
+          client.close();
+          throw error;
+        }
+        throw new InfraError(`Infra connector "redis": failed to connect to ${target} — ${errorMessage(error)}`);
+      } finally {
+        clearTimeout(timer);
       }
     },
     dispose(client) {

package/core/infra/index.ts

@@ -10,10 +10,10 @@ export { reader, requireValue, type ConfigReader } from "./connectorConfig";
 export { codexAppServerConnect, CODEX_APP_SERVER } from "./connectors/codex";
 export { CodexError, RU_CODEX_MESSAGES, type CodexErrorCode, CODEX_MODEL_ID, CODEX_REASONING_EFFORT, type CodexClient, type CodexConfigShape, type CodexLogin, type CodexLoginMethod, type CodexModel, type CodexStatus, type CodexRunInput, type CodexChatMessage, type CodexTool, type CodexToolCall, type CodexToolResult } from "./connectors/codex/contracts";
 
-export { postgres, POSTGRES, postgresConnectionOptions, type PostgresConfigShape, type PostgresSslMode, type PostgresConnectorOptions } from "./connectors/postgres";
+export { postgres, IPostgres, postgresConnectionOptions, type PostgresConfigShape, type PostgresSslMode, type PostgresConnectorOptions } from "./connectors/postgres";
 export {
   redisConnect,
-  REDIS,
+  IRedis,
   type RedisConfigShape,
   type RedisConnectorCacheMode,
   type RedisConnectorOptions,
@@ -26,7 +26,7 @@ export {
 } from "./cache";
 export {
   openSearchConnect,
-  OPENSEARCH,
+  IOpenSearch,
   OpenSearchClient,
   type OpenSearchClientOptions,
   type OpenSearchConfigShape,

package/core/kernel/Kernel.ts

@@ -95,7 +95,7 @@ export class Kernel {
     let startupDisposal: Promise<void> | undefined;
     if (this.options.startupTimeoutMs > 0) {
       startupTimer = setTimeout(
-        () => abortController.abort(new StartupTimeoutError(this.options.startupTimeoutMs)),
+        () => abortController.abort(new StartupTimeoutError(this.options.startupTimeoutMs, this.coordinator.startingServiceName)),
         this.options.startupTimeoutMs,
       );
     }

package/core/kernel/LifecycleCoordinator.ts

@@ -21,6 +21,13 @@ interface LifecycleResolver {
  * the {@link Kernel}, which bounds the whole graceful-stop sequence.
  */
 export class LifecycleCoordinator {
+  private startingName?: string;
+
+  /** The hosted service whose `start` is running now, for the startup timeout. */
+  public get startingServiceName(): string | undefined {
+    return this.startingName;
+  }
+
   private hooks: readonly LifecycleHook[] = [];
   /** Hosted services in actual start order (stop iterates in reverse). */
   private readonly started: HostedService[] = [];
@@ -81,6 +88,7 @@ export class LifecycleCoordinator {
         const group = phases[phaseIndex] as HostedService[];
         for (let index = 0; index < group.length; index += 1) {
           const service = group[index] as HostedService;
+          this.startingName = service.diagnosticName ?? service.constructor?.name;
           const starting = Promise.resolve().then(() => {
             signal?.throwIfAborted();
             return service.start(signal);
@@ -97,6 +105,7 @@ export class LifecycleCoordinator {
             throw error;
           }
           this.started.push(service);
+          this.startingName = undefined;
         }
       }
       this.hostedCount = this.started.length;

package/core/kernel/SupervisedHostedService.ts

@@ -47,6 +47,11 @@ export class SupervisedHostedService implements HostedService {
     });
   }
 
+  public get diagnosticName(): string | undefined {
+    const service = this.inner ?? this.prepared;
+    return service === undefined ? undefined : service.diagnosticName ?? service.constructor.name;
+  }
+
   /** Passed on to every attempt's service before it starts. */
   public useDiagnostics(diagnostics: HostedServiceDiagnostics): void {
     this.diagnostics = diagnostics;

package/core/kernel/errors/StartupTimeoutError.ts

@@ -1,7 +1,10 @@
-import { KernelError } from "./KernelError";
-
-export class StartupTimeoutError extends KernelError {
-  public constructor(public readonly timeoutMs: number) {
-    super(`Application startup did not finish within ${timeoutMs}ms.`);
+/**
+ * The start ran out of time. Not a configuration error: something it waited
+ * for did not answer, and `pending` names it when a hosted service was starting.
+ */
+export class StartupTimeoutError extends Error {
+  public constructor(public readonly timeoutMs: number, public readonly pending?: string) {
+    super(`Application startup did not finish within ${timeoutMs}ms${pending === undefined ? "." : `; still starting: ${pending}.`}`);
+    this.name = "StartupTimeoutError";
   }
 }

package/index.ts

@@ -82,6 +82,7 @@ export {
   AgentRuntime,
   AgentRuntimeError,
   AgentSemanticError,
+  AgentModelTimeoutError,
   AgentToolExecutionError,
   ToolError,
   ApproximateAgentContextTokenEstimator,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bazis",
-  "version": "0.99.4",
+  "version": "0.99.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",