bazis 0.96.1

package/core/agent/AgentToolHooks.ts

@@ -0,0 +1,39 @@
+import type { Class, BazisModuleRef } from "../di";
+import type { JsonObject, JsonValue, AgentToolResultStatus } from "./semantic";
+import type { ToolApproval, ToolSideEffect } from "./metadata";
+import type { AgentToolExecutionApproval } from "./AgentToolExecutor";
+
+export type AgentToolHookKindV1 = "enforcement" | "settlement" | "observer";
+
+export interface AgentToolHookRefV1 { readonly kind: AgentToolHookKindV1; readonly id: string; readonly version: number; }
+export interface AgentToolRequiredHookRefV1 extends AgentToolHookRefV1 { readonly owner: BazisModuleRef; }
+export interface AgentToolHookRegistrationBaseV1 extends AgentToolHookRefV1 { readonly order?: number; readonly timeoutMs?: number; }
+export type AgentToolHookRegistrationV1 =
+  | (AgentToolHookRegistrationBaseV1 & { readonly kind: "enforcement"; readonly handler: Class<AgentToolEnforcementHookV1>; })
+  | (AgentToolHookRegistrationBaseV1 & { readonly kind: "settlement"; readonly handler: Class<AgentToolSettlementHookV1>; })
+  | (AgentToolHookRegistrationBaseV1 & { readonly kind: "observer"; readonly handler: Class<AgentToolObserverHookV1>; });
+
+export interface AgentToolHookContextV1 { readonly signal: AbortSignal; readonly deadlineUnixMs: number; }
+export interface AgentToolCallProjectionV1 { readonly id: string; readonly name: string; readonly input: JsonValue; readonly metadata: JsonObject; }
+export interface AgentToolDescriptorProjectionV1 { readonly name: string; readonly description: string; readonly sideEffect: ToolSideEffect; readonly approval: ToolApproval; readonly tags: readonly string[]; }
+export interface AgentToolBeforeEffectEventV1 {
+  readonly type: "agent-tool.before-effect/v1"; readonly invocationId?: string; readonly agentName?: string;
+  readonly attempt: number; readonly maxAttempts: number; readonly idempotencyKey?: string;
+  readonly call: AgentToolCallProjectionV1; readonly tool: AgentToolDescriptorProjectionV1;
+  readonly executionApproval: AgentToolExecutionApproval;
+}
+export type AgentToolEnforcementDecisionV1 =
+  | { readonly decision: "allow"; readonly evidence?: JsonObject; }
+  | { readonly decision: "deny"; readonly reasonCode?: string; readonly message?: string; readonly evidence?: JsonObject; };
+export interface AgentToolEnforcementHookV1 { enforce(event: AgentToolBeforeEffectEventV1, context: AgentToolHookContextV1): AgentToolEnforcementDecisionV1 | Promise<AgentToolEnforcementDecisionV1>; }
+export interface AgentToolTerminalProjectionV1 { readonly status: AgentToolResultStatus; readonly executeStarted: boolean; readonly outcomeKnown: boolean; readonly retryable: boolean; readonly errorCode?: string; readonly output?: JsonValue; }
+export interface AgentToolSettlementEventV1 {
+  readonly type: "agent-tool.settlement/v1"; readonly callId: string; readonly toolName: string;
+  readonly invocationId?: string; readonly agentName?: string; readonly attempt?: number;
+  readonly beforeEffect?: AgentToolBeforeEffectEventV1; readonly terminal: AgentToolTerminalProjectionV1;
+}
+export interface AgentToolSettlementResultV1 { readonly status: "recorded"; readonly evidence?: JsonObject; }
+export interface AgentToolSettlementHookV1 { settle(event: AgentToolSettlementEventV1, context: AgentToolHookContextV1): AgentToolSettlementResultV1 | Promise<AgentToolSettlementResultV1>; }
+export interface AgentToolObserverEventV1 { readonly type: "agent-tool.observer/v1"; readonly settlement: AgentToolSettlementEventV1; }
+export interface AgentToolObserverHookV1 { observe(event: AgentToolObserverEventV1, context: AgentToolHookContextV1): void | Promise<void>; }
+export interface AgentToolAuditHookProjectionV1 extends AgentToolHookRefV1 { readonly tier: "platform" | "application"; readonly order: number; readonly outcome: "allowed" | "denied" | "recorded" | "failed" | "timed-out" | "cancelled" | "invalid-result"; readonly reasonCode?: string; readonly evidence?: JsonObject; }

package/core/agent/ModelProvider.ts

@@ -0,0 +1,21 @@
+import { createToken } from "../di";
+import type { AgentModelRequest, AgentModelResponse, JsonObject } from "./semantic";
+
+export interface AgentModelProviderContext {
+  readonly invocationId: string;
+  readonly agentName: string;
+  readonly modelProfile?: string;
+  readonly metadata: JsonObject;
+  readonly signal: AbortSignal;
+  /** Optional synchronous observer of provisional text. complete() remains authoritative. */
+  readonly onTextDelta?: (text: string) => void;
+}
+
+export interface AgentModelProvider {
+  complete(
+    request: AgentModelRequest,
+    context: AgentModelProviderContext,
+  ): AgentModelResponse | Promise<AgentModelResponse>;
+}
+
+export const AGENT_MODEL_PROVIDER = createToken<AgentModelProvider>("AgentModelProvider");

package/core/agent/README.md

@@ -0,0 +1,229 @@
+# bazis Agent
+
+`core/agent` is the first executable foundation for bazis AI. It contains
+provider-neutral metadata, discovery and DI-backed tool execution:
+
+- `@Agent`
+- `@Task`
+- `@Tool`
+- `@Prompt`
+- `collectAgentCatalog`
+- `AgentRegistry`
+- generated metadata via `bun run di:generate`
+- provider-neutral semantic model (`agentMessage`, `agentToolCall`,
+  `agentModelRequest`, `agentModelResponse`)
+- prompt/context rendering via `DefaultAgentContextBuilder`
+- DI-backed `AgentToolExecutor`
+
+Model providers live behind infra connectors. Long-term memory and streaming are
+still separate layers on top of this runtime boundary.
+
+```ts
+import { Agent, Module, Task, Tool, agentOutput } from "bazis";
+
+class CreateRequirementsRequest {
+  feature!: string;
+}
+
+class ProductRequirementsDocument {
+  goal!: string;
+  acceptanceCriteria!: string[];
+}
+
+@Tool({
+  name: "catalog.search",
+  description: "Searches products in the catalog.",
+  sideEffect: "read",
+})
+class SearchCatalogTool {}
+
+@Agent({
+  name: "system-analyst",
+  role: "System analyst",
+  sections: [
+    {
+      kind: "developer",
+      content: "Return concrete, testable requirements.",
+    },
+    {
+      kind: "tool-policy",
+      content: "Use read tools before proposing write actions.",
+    },
+  ],
+  tools: [SearchCatalogTool],
+  modelProfile: "reasoning",
+})
+class SystemAnalystAgent {
+  @Task({
+    name: "prepare-requirements",
+    description: "Prepare a requirements document for a product feature.",
+  })
+  prepareRequirements(input: CreateRequirementsRequest): ProductRequirementsDocument {
+    return agentOutput();
+  }
+}
+
+@Module({
+  agents: [SystemAnalystAgent],
+  tools: [SearchCatalogTool],
+})
+class ProductModule {}
+```
+
+The DI core does not know about agent metadata. Importing `@/core/agent` or
+the root `bazis` API extends `@Module` with `agents`, `tools` and `prompts`.
+Each entry in `tools` creates one ordinary scoped provider owned by that module.
+An existing exact scoped self-class provider is reused; incompatible lifetimes,
+duplicates, and conflicting owners are rejected before activation.
+`AgentRegistry.fromContainer(container)` returns the immutable host Tool catalog
+from these registrations without constructing Tools. Metadata-defined agents
+select their own subset through `AgentRegistry.fromDefinition(definition, catalog.listTools())`.
+Internal contribution readers use an Agent-owned view of these optional fields.
+This also allows an isolated HTTP host to type-check when `generatedRuntime`
+references `AgentRegistry` only as a type, without loading the public Agent barrel
+and its DI augmentation. Runtime validation and provider ownership are unchanged.
+For simple cases, put role/instructions/sections directly on `@Agent`. Use a
+separate `@Prompt` class when the prompt is reused, versioned, or owned outside
+one agent.
+
+For startup-friendly discovery, `bun run di:generate` writes
+`src/generated/bazis/agentCatalog.ts`. Use
+`AgentRegistry.fromGeneratedModules([AppModule])` when the runtime should prefer
+the generated metadata index and still respect module ownership.
+
+The semantic model is the provider-neutral language for future runtime/provider
+adapters:
+
+```ts
+const request = agentModelRequest({
+  invocationId: "inv-1",
+  messages: [agentMessage("user", "Prepare acceptance criteria")],
+  tools: [agentToolContract({
+    name: "catalog.search",
+    description: "Searches products.",
+    sideEffect: "read",
+  })],
+});
+```
+
+Tool execution stays behind bazis DI, agent visibility and approval policy:
+
+```ts
+import { modelValidatorAdapter } from "@/library/validation";
+
+const container = createContainer(AppModule);
+const registry = AgentRegistry.fromModules([AppModule]);
+const executor = new AgentToolExecutor(container, registry, {
+  schemaValidator: modelValidatorAdapter,
+  auditSink: (entry) => auditStore.write(entry),
+});
+
+const result = await executor.execute(agentToolCall({
+  id: "call-1",
+  name: "catalog.search",
+  input: { query: "keyboard" },
+}), {
+  agentName: "product-designer",
+});
+```
+
+Audit entries redact `input`, `result` and execution `metadata` by default
+using `bazis/library/redaction` (`password`, `secret`, `token`, `apiKey`,
+`authorization`, `cookie`, etc.). Raw audit traces are an explicit local-debug
+escape hatch: pass `auditRedaction: false` on the executor or one execution.
+
+Retries are opt-in. `write` and `external` tools require an idempotency key
+before the executor will repeat them:
+
+```ts
+await executor.execute(agentToolCall({
+  id: "call-2",
+  name: "catalog.reindex",
+}), {
+  agentName: "product-designer",
+  idempotencyKey: "catalog-reindex-1",
+  retryPolicy: { maxAttempts: 3, delayMs: 100, backoff: "exponential" },
+});
+```
+
+Runtime-generated idempotency keys include both the invocation id and the
+unique model call id. Use `idempotencyKeyForCall` for a domain-specific stable
+key. Tool scopes have a bounded disposal wait (`scopeDisposeTimeoutMs`, five
+seconds by default). When execution settles after a timeout/abort, audit sinks
+receive a terminal `settlement` entry; an unknown write outcome stops runtime
+continuation.
+
+Every tool call also has one 30-second deadline covering input validation,
+approval, audit, DI resolution, execution, output processing and result audit.
+Model provider calls default to 60 seconds. Set the corresponding `timeoutMs`
+to `0` only when an explicit compatibility opt-out is required.
+
+The first runtime slice invokes a model provider from infra, then routes tool
+calls through the executor:
+
+```ts
+const runtime = new AgentRuntime(
+  container,
+  AgentRegistry.fromModules([AppModule]),
+  container.resolve(AGENT_MODEL_PROVIDER),
+);
+
+const result = await runtime.invoke("product-designer", {
+  input: "Prepare acceptance criteria",
+  maxSteps: 4,
+});
+```
+
+For controller-style DX, prefer task methods on an agent. The task method is a
+business operation contract; the method body is not called by user code:
+
+```ts
+const result = await runtime.invokeTask("system-analyst", "prepare-requirements", {
+  feature: "Checkout with a promo code",
+});
+```
+
+`@Task` can declare `input` and `output` explicitly. With `bun run di:generate`,
+simple method signatures are also read from code and written to generated
+metadata for faster startup-friendly discovery.
+
+Prompt metadata is rendered into provider request context, not stored in the
+conversation history returned by the runtime:
+
+```ts
+const runtime = new AgentRuntime(container, registry, provider, {
+  contextLimits: { maxMessages: 24, maxTokens: 8_000, maxChars: 32_000 },
+});
+
+const result = await runtime.invoke("product-designer", {
+  input: "Prepare acceptance criteria",
+  contextLimits: { maxMessages: 12, maxTokens: 4_000 },
+});
+```
+
+`DefaultAgentContextBuilder` preserves the system prompt and newest conversation
+message when trimming old history. `maxTokens` uses a deterministic built-in
+estimator, and provider requests include `metadata.agentContext.trace` so context
+assembly is inspectable.
+
+LLM clients are registered by infra connectors, not inside agent modules. Agents
+name a model profile; infra owns provider URLs, model ids, limits and fallback:
+
+```ts
+@Infra({
+  llm: llmRouter({
+    fast: llmProfile(llmConfig, openAiCompatibleAdapter(), {
+      model: "gpt-4.1-mini",
+      temperature: 0.1,
+      maxOutputTokens: 1000,
+    }),
+    reasoning: llmProfile(llmConfig, openAiCompatibleAdapter(), {
+      model: "gpt-4.1",
+      temperature: 0.2,
+      maxOutputTokens: 4000,
+      fallback: "fast",
+    }),
+  }, { defaultProfile: "fast" }),
+})
+class AppInfra {}
+```

package/core/agent/Tool.contract.ts

@@ -0,0 +1,20 @@
+import { getGeneratedOpenApiMetadata, getGeneratedOpenApiSchemaName } from "../http/OpenApi/generatedOpenApiRegistry";
+import type { ToolDefinition } from "./AgentRegistry";
+import { inlineGeneratedSchema } from "./internal/Schema.contract";
+import { agentClassSchema, agentJsonSchema, agentToolContract } from "./semantic";
+
+/** The same generated contract is used by the local runtime and external executors. */
+export function describeTool(tool: ToolDefinition) {
+  const schema = (model: NonNullable<ToolDefinition["metadata"]["input"]>) => {
+    const schemas = getGeneratedOpenApiMetadata().schemas;
+    const name = getGeneratedOpenApiSchemaName(model) ?? model.name;
+    return schemas[name] === undefined ? agentClassSchema(name)
+      : agentJsonSchema(name, inlineGeneratedSchema(schemas[name], schemas));
+  };
+  return agentToolContract({
+    name: tool.metadata.name, description: tool.metadata.description,
+    input: tool.metadata.input ? schema(tool.metadata.input) : undefined,
+    output: tool.metadata.output ? schema(tool.metadata.output) : undefined,
+    sideEffect: tool.metadata.sideEffect, approval: tool.metadata.approval, timeoutMs: tool.metadata.timeoutMs,
+  });
+}

package/core/agent/decorators/Agent.ts

@@ -0,0 +1,11 @@
+import { defineAgentMetadata, type AgentOptions } from "../metadata";
+
+/**
+ * Declares an executable agent class. The class stays a regular DI service;
+ * this decorator only adds framework metadata for discovery and validation.
+ */
+export function Agent(options: AgentOptions = {}) {
+  return (value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext): void => {
+    defineAgentMetadata(value, context.metadata, options);
+  };
+}

package/core/agent/decorators/Prompt.ts

@@ -0,0 +1,11 @@
+import { definePromptMetadata, type PromptOptions } from "../metadata";
+
+/**
+ * Declares a reusable prompt contract. Prompts are metadata classes so modules
+ * can own and version them without exposing provider-specific APIs.
+ */
+export function Prompt(options: PromptOptions = {}) {
+  return (value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext): void => {
+    definePromptMetadata(value, context.metadata, options);
+  };
+}

package/core/agent/decorators/Task.ts

@@ -0,0 +1,29 @@
+import { defineAgentTaskMetadata, type AgentTaskOptions } from "../metadata";
+
+type TaskDecorator = (value: (...args: never[]) => unknown, context: ClassMethodDecoratorContext) => void;
+
+export type TaskDecoratorOptions = string | AgentTaskOptions;
+
+function normalizeOptions(options: TaskDecoratorOptions | undefined): AgentTaskOptions {
+  if (options === undefined) {
+    return {};
+  }
+  if (typeof options === "string") {
+    return { name: options };
+  }
+  return options;
+}
+
+/**
+ * Declares an executable agent task on an @Agent class. This mirrors
+ * controller action decorators: the method is a business operation contract,
+ * while AgentRuntime performs the actual AI execution.
+ */
+export function Task(options?: TaskDecoratorOptions): TaskDecorator {
+  return (_value, context) => {
+    if (context.static || context.private) {
+      throw new Error(`@Task supports public instance methods only ("${String(context.name)}").`);
+    }
+    defineAgentTaskMetadata(context.name, context.metadata, normalizeOptions(options));
+  };
+}

package/core/agent/decorators/Tool.ts

@@ -0,0 +1,12 @@
+import { defineToolMetadata, type ToolOptions } from "../metadata";
+
+/**
+ * Declares a tool callable by an agent. Side-effect and approval metadata is
+ * required by the future runtime policy layer; unsafe write/external tools are
+ * approval-gated by default.
+ */
+export function Tool(options: ToolOptions) {
+  return (value: abstract new (...args: never[]) => unknown, context: ClassDecoratorContext): void => {
+    defineToolMetadata(value, context.metadata, options);
+  };
+}

package/core/agent/errors.ts

@@ -0,0 +1,43 @@
+/** Error thrown while declaring or discovering Bazis agent metadata. */
+export class AgentSetupError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AgentSetupError";
+  }
+}
+
+/** Error thrown when provider-neutral agent semantic objects are invalid. */
+export class AgentSemanticError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AgentSemanticError";
+  }
+}
+
+/** Error thrown when an agent tool executor is configured incorrectly. */
+export class AgentToolExecutionError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AgentToolExecutionError";
+  }
+}
+
+/**
+ * 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.
+ */
+export class AgentToolPreCommitError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AgentToolPreCommitError";
+  }
+}
+
+/** Error thrown when the agent runtime is configured incorrectly. */
+export class AgentRuntimeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "AgentRuntimeError";
+  }
+}

package/core/agent/generated/catalog.ts

@@ -0,0 +1,26 @@
+// This file is auto-generated by `bun run di:generate`.
+// Do not edit manually.
+
+import type { Class } from "../../di";
+import type { AgentMetadataIndex } from "../AgentRegistry";
+import type { AgentMetadata, PromptMetadata, ToolMetadata } from "../metadata";
+
+function readonlyMetadataMap<K, V>(entries: readonly (readonly [K, V])[]): ReadonlyMap<K, V> {
+  const lookup = new Map<K, V>(entries);
+  const facade: ReadonlyMap<K, V> = {
+    get size() { return lookup.size; }, has: (key) => lookup.has(key), get: (key) => lookup.get(key),
+    entries: () => lookup.entries(), keys: () => lookup.keys(), values: () => lookup.values(),
+    forEach: (callback, thisArg) => { for (const [key, value] of lookup) callback.call(thisArg, value, key, facade); },
+    [Symbol.iterator]: () => lookup[Symbol.iterator](),
+  };
+  return Object.freeze(facade);
+}
+
+export const GENERATED_AGENT_METADATA: AgentMetadataIndex = Object.freeze({
+  agents: readonlyMetadataMap<Class<object>, AgentMetadata>([
+  ]),
+  tools: readonlyMetadataMap<Class<object>, ToolMetadata>([
+  ]),
+  prompts: readonlyMetadataMap<Class<object>, PromptMetadata>([
+  ]),
+});

package/core/agent/index.ts

@@ -0,0 +1,170 @@
+import type { Class } from "../di";
+
+export { Agent } from "./decorators/Agent";
+export { Prompt } from "./decorators/Prompt";
+export { Task, type TaskDecoratorOptions } from "./decorators/Task";
+export { Tool } from "./decorators/Tool";
+export { describeTool } from "./Tool.contract";
+export type {
+  AgentToolHookKindV1, AgentToolHookRefV1, AgentToolRequiredHookRefV1, AgentToolHookRegistrationBaseV1,
+  AgentToolHookRegistrationV1, AgentToolHookContextV1, AgentToolCallProjectionV1, AgentToolDescriptorProjectionV1,
+  AgentToolBeforeEffectEventV1, AgentToolEnforcementDecisionV1, AgentToolEnforcementHookV1,
+  AgentToolTerminalProjectionV1, AgentToolSettlementEventV1, AgentToolSettlementResultV1,
+  AgentToolSettlementHookV1, AgentToolObserverEventV1, AgentToolObserverHookV1, AgentToolAuditHookProjectionV1,
+} from "./AgentToolHooks";
+export {
+  AgentRuntimeError,
+  AgentSemanticError,
+  AgentSetupError,
+  AgentToolExecutionError,
+  AgentToolPreCommitError,
+} from "./errors";
+export {
+  AgentRuntime,
+  type AgentRuntimeInvokeOptions,
+  type AgentRuntimeOptions,
+  type AgentRuntimeResult,
+  type AgentRuntimeStatus,
+  type AgentRuntimeTaskInvokeOptions,
+  type AgentRuntimeToolCallContext,
+  type AgentRuntimeToolExecutionOptions,
+} from "./AgentRuntime";
+export {
+  ApproximateAgentContextTokenEstimator,
+  DefaultAgentContextBuilder,
+  mergeAgentContextLimits,
+  normalizeAgentContextLimits,
+  type AgentContext,
+  type AgentContextBuildInput,
+  type AgentContextBuilder,
+  type AgentContextLimits,
+  type AgentContextTokenEstimator,
+  type AgentContextTraceEntry,
+  type DefaultAgentContextBuilderOptions,
+} from "./AgentContextBuilder";
+export {
+  AgentToolExecutor,
+  type AgentExecutableTool,
+  type AgentToolAuditEntry,
+  type AgentToolAuditFailureMode,
+  type AgentToolAuditFunction,
+  type AgentToolAuditPhase,
+  type AgentToolAuditSink,
+  type AgentToolAuditSinkObject,
+  type AgentToolAuditToolInfo,
+  type AgentToolApprovalDecision,
+  type AgentToolApprovalFunction,
+  type AgentToolApprovalPolicy,
+  type AgentToolApprovalPolicyObject,
+  type AgentToolApprovalReason,
+  type AgentToolApprovalRequest,
+  type AgentToolExecutionApproval,
+  type AgentToolExecutionContext,
+  type AgentToolExecutionOptions,
+  type AgentToolExecutorOptions,
+  type AgentToolRetryBackoff,
+  type AgentToolRetryPolicy,
+  type AgentToolSchemaValidator,
+  type AgentToolValidationIssue,
+  type AgentToolValidationResult,
+} from "./AgentToolExecutor";
+export {
+  AGENT_MODEL_PROVIDER,
+  type AgentModelProvider,
+  type AgentModelProviderContext,
+} from "./ModelProvider";
+export {
+  AgentRegistry,
+  collectAgentCatalog,
+  type AgentCatalog,
+  type AgentCatalogExtras,
+  type AgentDefinition,
+  type AgentMetadataIndex,
+  type AgentTaskDefinition,
+  type PromptDefinition,
+  type ToolDefinition,
+} from "./AgentRegistry";
+export type { AgentDataDefinition } from "./AgentDataDefinition";
+export {
+  agentMetadataOf,
+  agentTaskMetadataOf,
+  promptMetadataOf,
+  toolMetadataOf,
+  type AgentMetadata,
+  type AgentOptions,
+  type AgentTaskMetadata,
+  type AgentTaskOptions,
+  type PromptMetadata,
+  type PromptOptions,
+  type PromptSectionKind,
+  type PromptSectionMetadata,
+  type PromptSectionOptions,
+  type ToolApproval,
+  type ToolMetadata,
+  type ToolOptions,
+  type ToolSideEffect,
+} from "./metadata";
+export {
+  agentClassSchema,
+  agentData,
+  agentFile,
+  agentImage,
+  agentInvocation,
+  agentJsonSchema,
+  agentMessage,
+  agentModelCapabilities,
+  agentModelRequest,
+  agentModelResponse,
+  agentOutput,
+  agentOutputContract,
+  agentText,
+  agentToolCall,
+  agentToolCallPart,
+  agentToolContract,
+  agentToolResult,
+  agentToolResultPart,
+  normalizeJsonValue,
+  type AgentClassSchemaContract,
+  type AgentContentInput,
+  type AgentContentPart,
+  type AgentDataPart,
+  type AgentFilePart,
+  type AgentFinishReason,
+  type AgentImagePart,
+  type AgentInvocation,
+  type AgentInvocationOptions,
+  type AgentJsonSchemaContract,
+  type AgentMessage,
+  type AgentMessageOptions,
+  type AgentMessageRole,
+  type AgentModelCapabilities,
+  type AgentModelRequest,
+  type AgentModelResponse,
+  type AgentOutputContract,
+  type AgentOutputMode,
+  type AgentSchemaContract,
+  type AgentStreamEvent,
+  type AgentTextPart,
+  type AgentToolCall,
+  type AgentToolCallPart,
+  type AgentToolContract,
+  type AgentToolError,
+  type AgentToolResult,
+  type AgentToolResultPart,
+  type AgentToolResultStatus,
+  type AgentUsage,
+  type JsonObject,
+  type JsonPrimitive,
+  type JsonValue,
+} from "./semantic";
+
+// Augment the declaring file, not the "../di" re-export: re-export targets
+// depend on program file order and silently stop merging in some projects.
+declare module "../di/module/types/BazisModule" {
+  interface BazisModuleMetadata {
+    readonly agents?: readonly Class<object>[];
+    readonly tools?: readonly Class<object>[];
+    readonly prompts?: readonly Class<object>[];
+    readonly agentToolHooks?: readonly import("./AgentToolHooks").AgentToolHookRegistrationV1[];
+  }
+}