bazis 0.98.34 → 0.99.1

package/core/scripts/di-generate.ts

@@ -7,7 +7,7 @@ import {
   type OpenApiCodegenOperationSpec,
   type OpenApiCodegenSchema,
 } from "../../library/openapi/codegen";
-import { generateAgentMetadataCatalog, type AgentCodegenSource } from "./agent-codegen";
+import { collectToolSchemaModels, type ToolCodegenSource } from "./tool-codegen";
 import {
   analyzeRequestModelHydration,
   type RequestModelHydration,
@@ -30,8 +30,6 @@ const FRAMEWORK_SOURCE = ((): string | null => {
   try { return realpathSync("src/bazis") === FRAMEWORK_DIR ? "src/bazis" : null; } catch { return null; }
 })();
 const FRAMEWORK_ROOT = FRAMEWORK_SOURCE ?? "src/bazis";
-const CORE_AGENT_CATALOG_FILE = `${FRAMEWORK_ROOT}/core/agent/generated/catalog.ts`;
-const CORE_AGENT_GENERATED_DIR = `${FRAMEWORK_ROOT}/core/agent/generated`;
 const isFrameworkSourcePath = (file: string): boolean => FRAMEWORK_SOURCE !== null && file.startsWith(`${FRAMEWORK_SOURCE}/`);
 const APP_GENERATED_DIR = "src/generated/bazis";
 let activeGeneratedDir = APP_GENERATED_DIR;
@@ -209,10 +207,10 @@ let ambiguousClassNames = new Set<string>();
 // Exact roots that do not need convention name resolution: @RequestModel()
 // classes used by generated transport schemas.
 let explicitRequestModelRoots = new Set<ts.ClassDeclaration>();
-let agentCodegenSources: AgentCodegenSource[] = [];
+let toolCodegenSources: ToolCodegenSource[] = [];
 
 const ROUTE_DECORATORS = new Set(["Get", "Post", "Put", "Patch", "Delete", "Options", "Head", "All"]);
-const CODEGEN_CHANNEL_DECORATORS = new Set(["Controller", "GrpcController", "WebSocketGateway", "Agent", "Tool", "Prompt", "RequestModel", "UiProfile"]);
+const CODEGEN_CHANNEL_DECORATORS = new Set(["Controller", "GrpcController", "WebSocketGateway", "Tool", "RequestModel", "UiProfile"]);
 const PRIMITIVE_QUERY_TYPES: Record<string, HttpBindingSpec["type"]> = {
   string: "string",
   number: "number",
@@ -251,12 +249,7 @@ const BUILTIN_DEPENDENCY_NAMES = new Set([
 function isScannableFile(filePath: string): boolean {
   if (filePath.startsWith("../") || path.isAbsolute(filePath)) return false;
   if (!filePath.endsWith(".ts") || filePath.endsWith(".d.ts") || /\.(test|spec)\.ts$/.test(filePath)) return false;
-  if (
-    filePath === CORE_AGENT_CATALOG_FILE ||
-    filePath.startsWith(`${APP_GENERATED_DIR}/`)
-  ) {
-    return false;
-  }
+  if (filePath.startsWith(`${APP_GENERATED_DIR}/`)) return false;
   return !/(^|\/)(test|tests|__tests__|fixture|fixtures|__fixtures__|generated|node_modules|vendor|dist|build|bin|coverage|examples)(\/|$)/.test(filePath) && !filePath.startsWith("admin-ui/");
 }
 
@@ -414,7 +407,7 @@ function sourceHasCodegenCandidate(source: ts.SourceFile): boolean {
       const decorators = ts.getDecorators(node) ?? [];
       const constructorDeps = readConstructorTypeNames(node);
       // Shared all-channel boundary index: any class that feeds DI/HTTP,
-      // request/list, OpenAPI/UI, Agent/Tool/Prompt analysis must
+      // request/list, OpenAPI/UI, Tool analysis must
       // be owned by exactly one configured target before rendering begins.
       if (
         decorators.some((decorator) => {
@@ -456,7 +449,7 @@ function resetTargetAnalysis(files: Set<string>, generatedDir: string): void {
   httpBindings = {}; httpControllerFiles = {}; openApiSchemas = {}; openApiOperations = {};
   grpcBindings = new Map();
   uiProfileResponseModels = new Map(); openApiSchemaModels = new Map(); requestModelClassNames = new Set(); listRequestClassNames = new Set();
-  classFilesByName = new Map(); classDeclarationsByName = new Map(); ambiguousClassNames = new Set(); explicitRequestModelRoots = new Set(); agentCodegenSources = [];
+  classFilesByName = new Map(); classDeclarationsByName = new Map(); ambiguousClassNames = new Set(); explicitRequestModelRoots = new Set(); toolCodegenSources = [];
   sourceEntries = [...files].sort((a, b) => a.localeCompare(b)).map((filePath) => ({ filePath, source: programFiles.get(filePath) as ts.SourceFile }));
   sourceFilePathSet = new Set(sourceEntries.map((entry) => entry.filePath));
   openApiCodegen = createOpenApiCodegenAnalyzer({ checker, sourceFiles: sourceEntries.map((entry) => entry.source), schemaNameForDuplicate: duplicateOpenApiSchemaName });
@@ -478,7 +471,7 @@ async function generateTarget(name: string, reachable: Set<string>, production:
     if (!FRAMEWORK_INTERNAL_PREFIXES.some((prefix) => filePath.startsWith(prefix))) {
       collectClassDeps(source);
       collectGrpcBindings(source);
-      agentCodegenSources.push({ filePath, sourceFile: source });
+      toolCodegenSources.push({ filePath, sourceFile: source });
     }
     collectHttpBindings(source); collectOpenApiSchemas(source); collectUiProfileResponseModels(source);
   }
@@ -487,46 +480,39 @@ async function generateTarget(name: string, reachable: Set<string>, production:
   const requestModelImports = resolveRequestModelImports();
   const requestModelHydration = resolveRequestModelHydration(requestModelImports);
   const listModelImports = resolveListModelImports();
-  const agent = generateAgentMetadataCatalog(agentCodegenSources, {
-    generatedDir, frameworkImports: "public", schemaNameForDeclaration: openApiCodegen.schemaNameForDeclaration,
-  });
-  const schemaModels = resolveOpenApiSchemaModelImports(agent.schemaModels, agent.schemaNames);
-  classifyAgentWarnings(agent.warnings); failOnFatalErrors();
+  const tools = collectToolSchemaModels(toolCodegenSources, { schemaNameForDeclaration: openApiCodegen.schemaNameForDeclaration });
+  const schemaModels = resolveOpenApiSchemaModelImports(tools.schemaModels, tools.schemaNames);
+  classifyToolWarnings(tools.warnings); failOnFatalErrors();
   const analysisMs = performance.now() - startedAt;
   const renderStartedAt = performance.now();
   const requestModels = renderRequestModels(requestModelImports, requestModelHydration);
   const listModels = renderListModels(listModelImports);
-  const openApi = renderOpenApiMetadata(openApiSchemas, openApiOperations, "app", agent.schemaNames, schemaModels);
+  const openApi = renderOpenApiMetadata(openApiSchemas, openApiOperations, "app", tools.schemaNames, schemaModels);
   stageWrite(`${generatedDir}/deps.ts`, renderTargetDeps());
   stageWrite(`${generatedDir}/bindings.ts`, renderTargetBindings());
   stageWrite(`${generatedDir}/httpRequestModels.ts`, requestModels);
   stageWrite(`${generatedDir}/httpListModels.ts`, listModels);
   stageWrite(`${generatedDir}/openapi.ts`, openApi);
-  stageWrite(`${generatedDir}/agentCatalog.ts`, agent.output);
+  // Generated before 0.99.0, when agents were classes; nothing imports it now.
+  stageRemove(`${generatedDir}/agentCatalog.ts`);
   stageWrite(`${generatedDir}/runtime.ts`, renderGeneratedRuntime(name));
   if (production) stageWrite(`${generatedDir}/fingerprint.ts`, renderSourceFingerprint());
-  // The framework's own empty agent catalog (a fixture of agent.metadata.test)
-  // is refreshed only when the framework source is part of this project.
-  if (production) {
-    if (FRAMEWORK_SOURCE !== null) {
-      stageWrite(CORE_AGENT_CATALOG_FILE, generateAgentMetadataCatalog([], CORE_AGENT_GENERATED_DIR).output);
-    }
-  } else {
+  if (!production) {
     stageWrite(`${generatedDir}/bootstrap.ts`, 'import { registerBazisGeneratedRuntime } from "./runtime";\n\nawait registerBazisGeneratedRuntime();\n');
   }
   for (const warning of warnings) console.warn(`[di:generate] WARNING: ${warning}`);
-  console.log(`[di:generate] target=${name} sources=${sourceEntries.length} deps=${classDeps.size} controllers=${Object.keys(httpBindings).length} requestModels=${requestModelImports.length} listModels=${listModelImports.length} agents=${agent.agentCount} prepassMs=${prepassMs.toFixed(1)} analysisMs=${analysisMs.toFixed(1)} totalMs=${(performance.now() - startedAt).toFixed(1)}`);
+  console.log(`[di:generate] target=${name} sources=${sourceEntries.length} deps=${classDeps.size} controllers=${Object.keys(httpBindings).length} requestModels=${requestModelImports.length} listModels=${listModelImports.length} tools=${tools.toolCount} prepassMs=${prepassMs.toFixed(1)} analysisMs=${analysisMs.toFixed(1)} totalMs=${(performance.now() - startedAt).toFixed(1)}`);
   return {
     analysisMs,
     renderMs: performance.now() - renderStartedAt,
     eligible: sourceEntries.length,
-    candidates: classDeps.size + Object.keys(httpBindings).length + requestModelImports.length + listModelImports.length + agent.agentCount,
+    candidates: classDeps.size + Object.keys(httpBindings).length + requestModelImports.length + listModelImports.length + tools.toolCount,
   };
 }
 
-function classifyAgentWarnings(agentWarnings: readonly string[]): void {
-  for (let index = 0; index < agentWarnings.length; index += 1) {
-    const warning = agentWarnings[index] as string;
+function classifyToolWarnings(toolWarnings: readonly string[]): void {
+  for (let index = 0; index < toolWarnings.length; index += 1) {
+    const warning = toolWarnings[index] as string;
     if (warning.includes("ambiguous") || warning.includes("declared in more than one file")) {
       fatalErrors.push(warning);
     } else {
@@ -561,8 +547,8 @@ function renderGeneratedRuntime(targetId: string): string {
       "}",
       "",
       "async function loadTarget(): Promise<void> {",
-      "  const [deps, bindings, requests, lists, openApi, agentCatalog] = await Promise.all([import(\"./deps\"), import(\"./bindings\"), import(\"./httpRequestModels\"), import(\"./httpListModels\"), import(\"./openapi\"), import(\"./agentCatalog\")]);",
-      `  await registerBazisGeneratedTargetDescriptor({ id: ${JSON.stringify(targetId)}, classDeps: deps.GENERATED_TARGET_CLASS_DEPS, bindings: bindings.GENERATED_TARGET_BINDINGS, providerAttachments: bindings.GENERATED_PROVIDER_ATTACHMENTS, requestModels: requests.GENERATED_REQUEST_MODELS, requestShapes: requests.GENERATED_REQUEST_MODEL_SHAPES, listModels: lists.GENERATED_LIST_MODELS, openApi: openApi.GENERATED_OPENAPI_METADATA, openApiSchemaModels: openApi.GENERATED_OPENAPI_SCHEMA_MODELS, agentMetadata: agentCatalog.GENERATED_AGENT_METADATA });`,
+      "  const [deps, bindings, requests, lists, openApi] = await Promise.all([import(\"./deps\"), import(\"./bindings\"), import(\"./httpRequestModels\"), import(\"./httpListModels\"), import(\"./openapi\")]);",
+      `  await registerBazisGeneratedTargetDescriptor({ id: ${JSON.stringify(targetId)}, classDeps: deps.GENERATED_TARGET_CLASS_DEPS, bindings: bindings.GENERATED_TARGET_BINDINGS, providerAttachments: bindings.GENERATED_PROVIDER_ATTACHMENTS, requestModels: requests.GENERATED_REQUEST_MODELS, requestShapes: requests.GENERATED_REQUEST_MODEL_SHAPES, listModels: lists.GENERATED_LIST_MODELS, openApi: openApi.GENERATED_OPENAPI_METADATA, openApiSchemaModels: openApi.GENERATED_OPENAPI_SCHEMA_MODELS });`,
       "}",
       "",
     ].join("\n");
@@ -582,8 +568,8 @@ function renderGeneratedRuntime(targetId: string): string {
     "  // Test-only owner-private hook: it is inert unless an isolated test installs it before loading this generated module.",
     '  (globalThis as { __bazisGeneratedRuntimeTestHook?: (target: string) => void }).__bazisGeneratedRuntimeTestHook?.("production");',
     '  const { registerBazisGeneratedTargetDescriptor, warnIfGeneratedSourcesChanged } = await import("bazis/core/generatedRuntime");',
-    "  const [deps, bindings, requests, lists, openApi, agentCatalog] = await Promise.all([import(\"./deps\"), import(\"./bindings\"), import(\"./httpRequestModels\"), import(\"./httpListModels\"), import(\"./openapi\"), import(\"./agentCatalog\")]);",
-    `  await registerBazisGeneratedTargetDescriptor({ id: ${JSON.stringify(targetId)}, classDeps: deps.GENERATED_TARGET_CLASS_DEPS, bindings: bindings.GENERATED_TARGET_BINDINGS, providerAttachments: bindings.GENERATED_PROVIDER_ATTACHMENTS, requestModels: requests.GENERATED_REQUEST_MODELS, requestShapes: requests.GENERATED_REQUEST_MODEL_SHAPES, listModels: lists.GENERATED_LIST_MODELS, openApi: openApi.GENERATED_OPENAPI_METADATA, openApiSchemaModels: openApi.GENERATED_OPENAPI_SCHEMA_MODELS, agentMetadata: agentCatalog.GENERATED_AGENT_METADATA });`,
+    "  const [deps, bindings, requests, lists, openApi] = await Promise.all([import(\"./deps\"), import(\"./bindings\"), import(\"./httpRequestModels\"), import(\"./httpListModels\"), import(\"./openapi\")]);",
+    `  await registerBazisGeneratedTargetDescriptor({ id: ${JSON.stringify(targetId)}, classDeps: deps.GENERATED_TARGET_CLASS_DEPS, bindings: bindings.GENERATED_TARGET_BINDINGS, providerAttachments: bindings.GENERATED_PROVIDER_ATTACHMENTS, requestModels: requests.GENERATED_REQUEST_MODELS, requestShapes: requests.GENERATED_REQUEST_MODEL_SHAPES, listModels: lists.GENERATED_LIST_MODELS, openApi: openApi.GENERATED_OPENAPI_METADATA, openApiSchemaModels: openApi.GENERATED_OPENAPI_SCHEMA_MODELS });`,
     "  // Started from sources edited after codegen: say so instead of silently missing routes.",
     '  warnIfGeneratedSourcesChanged(import.meta.dir, (await import("./fingerprint")).GENERATED_SOURCE_FINGERPRINT);',
     "}",
@@ -1348,11 +1334,11 @@ function resolveUiProfileResponseModelImports(): OpenApiSchemaModelImport[] {
       || sourcePathForDeclaration(left.declaration).localeCompare(sourcePathForDeclaration(right.declaration)));
 }
 
-/** Agent DTOs and their referenced classes share the existing nominal OpenAPI registry. */
-function resolveOpenApiSchemaModelImports(agentModels: readonly ts.ClassDeclaration[], agentNames: readonly string[]): OpenApiSchemaModelImport[] {
+/** Tool contracts and their referenced classes share the existing nominal OpenAPI registry. */
+function resolveOpenApiSchemaModelImports(toolModels: readonly ts.ClassDeclaration[], toolNames: readonly string[]): OpenApiSchemaModelImport[] {
   const models = new Map(resolveUiProfileResponseModelImports().map((model) => [model.declaration, model.schemaName]));
   // Empty class contracts still have a real object schema and must survive filtering.
-  for (const declaration of agentModels) {
+  for (const declaration of toolModels) {
     const name = openApiCodegen.schemaNameForDeclaration(declaration.name!.text, declaration);
     openApiSchemas[name] ??= openApiCodegen.schemaFromDeclaration(declaration);
     models.set(declaration, name);
@@ -1363,11 +1349,11 @@ function resolveOpenApiSchemaModelImports(agentModels: readonly ts.ClassDeclarat
     reachable.add(name);
     collectSchemaRefs(openApiSchemas[name], add);
   };
-  for (const name of agentNames) add(name);
+  for (const name of toolNames) add(name);
   for (const [declaration, name] of openApiSchemaModels) {
     if (!reachable.has(name)) continue;
     if (!isNamedExportedTopLevelClass(declaration)) {
-      fatalErrors.push(`BAZIS_AGENT_SCHEMA_MODEL_UNIMPORTABLE: Agent schema ${name} must be a named exported top-level class (${sourcePathForDeclaration(declaration)}).`);
+      fatalErrors.push(`BAZIS_TOOL_SCHEMA_MODEL_UNIMPORTABLE: Tool schema ${name} must be a named exported top-level class (${sourcePathForDeclaration(declaration)}).`);
       continue;
     }
     openApiSchemas[name] ??= openApiCodegen.schemaFromDeclaration(declaration);

package/core/scripts/tool-codegen.ts

@@ -0,0 +1,122 @@
+import ts from "typescript";
+
+export interface ToolCodegenSource {
+  readonly filePath: string;
+  /** Program-owned AST; codegen never reparses application source. */
+  readonly sourceFile?: ts.SourceFile;
+  /** Test fixture input; project generation always supplies sourceFile. */
+  readonly content?: string;
+}
+
+export interface ToolCodegenResult {
+  readonly warnings: readonly string[];
+  readonly toolCount: number;
+  /** `input`/`output` classes of `@Tool` declarations: they get JSON schemas in the OpenAPI registry. */
+  readonly schemaNames: readonly string[];
+  /** Program-owned declarations of those classes, for nominal schema bindings. */
+  readonly schemaModels: readonly ts.ClassDeclaration[];
+}
+
+export interface ToolCodegenOptions {
+  /** Use the same naming policy as the project's OpenAPI analyzer. */
+  readonly schemaNameForDeclaration?: (name: string, declaration: ts.ClassDeclaration) => string;
+}
+
+/**
+ * Finds `@Tool({ input, output })` classes. Tool metadata itself is read at
+ * runtime from the decorator; codegen only makes sure the contract classes
+ * have generated JSON schemas for the model and for validation.
+ */
+export function collectToolSchemaModels(
+  sources: readonly ToolCodegenSource[],
+  options: ToolCodegenOptions = {},
+): ToolCodegenResult {
+  const warnings: string[] = [];
+  const declarations = new Map<string, ts.ClassDeclaration>();
+  const files = new Map<string, string>();
+  const ambiguous = new Set<string>();
+  const parsed = sources.map((source) =>
+    source.sourceFile ?? ts.createSourceFile(source.filePath, source.content ?? "", ts.ScriptTarget.ESNext, true, ts.ScriptKind.TS));
+
+  for (const source of parsed) {
+    visitClasses(source, (node) => {
+      const name = node.name!.text;
+      const existing = files.get(name);
+      if (existing === undefined) files.set(name, source.fileName);
+      else if (existing !== source.fileName) ambiguous.add(name);
+      declarations.set(name, node);
+    });
+  }
+
+  const contractNames = new Set<string>();
+  let toolCount = 0;
+  for (const source of parsed) {
+    visitClasses(source, (node) => {
+      const call = toolDecoratorCall(node);
+      if (call === undefined) return;
+      const className = node.name!.text;
+      const where = sourceLocation(source, node);
+      if (!isNamedExportedClass(node)) {
+        warnings.push(`@Tool class "${className}" (${where}) is not a named export; codegen can only import named-export classes.`);
+        return;
+      }
+      toolCount += 1;
+      const options = call.arguments[0];
+      if (options === undefined || !ts.isObjectLiteralExpression(options)) return;
+      for (const property of options.properties) {
+        if (!ts.isPropertyAssignment(property)) continue;
+        const key = ts.isIdentifier(property.name) || ts.isStringLiteralLike(property.name) ? property.name.text : undefined;
+        if (key !== "input" && key !== "output") continue;
+        if (!ts.isIdentifier(property.initializer)) {
+          warnings.push(`@Tool ${className} (${where}): ${key} must be a class identifier.`);
+          continue;
+        }
+        const contract = property.initializer.text;
+        if (ambiguous.has(contract)) {
+          warnings.push(`@Tool ${className} (${where}): ${key} class "${contract}" is declared in more than one file.`);
+          continue;
+        }
+        contractNames.add(contract);
+      }
+    });
+  }
+
+  const schemaModels = [...contractNames]
+    .map((name) => declarations.get(name))
+    .filter((declaration): declaration is ts.ClassDeclaration => declaration !== undefined);
+  return {
+    warnings: Object.freeze(warnings),
+    toolCount,
+    schemaNames: Object.freeze(schemaModels
+      .map((declaration) => options.schemaNameForDeclaration?.(declaration.name!.text, declaration) ?? declaration.name!.text)
+      .sort((left, right) => left.localeCompare(right))),
+    schemaModels: Object.freeze(schemaModels),
+  };
+}
+
+function visitClasses(source: ts.SourceFile, onClass: (node: ts.ClassDeclaration) => void): void {
+  const visit = (node: ts.Node): void => {
+    if (ts.isClassDeclaration(node) && node.name) onClass(node);
+    ts.forEachChild(node, visit);
+  };
+  ts.forEachChild(source, visit);
+}
+
+function toolDecoratorCall(node: ts.ClassDeclaration): ts.CallExpression | undefined {
+  for (const decorator of ts.getDecorators(node) ?? []) {
+    const expression = decorator.expression;
+    if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && expression.expression.text === "Tool") return expression;
+  }
+  return undefined;
+}
+
+function isNamedExportedClass(node: ts.ClassDeclaration): boolean {
+  const modifiers = ts.getModifiers(node) ?? [];
+  return modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword)
+    && !modifiers.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword);
+}
+
+function sourceLocation(source: ts.SourceFile, node: ts.Node): string {
+  const position = source.getLineAndCharacterOfPosition(node.getStart(source));
+  return `${source.fileName}:${position.line + 1}:${position.character + 1}`;
+}

package/index.ts

@@ -78,60 +78,44 @@ export {
 } from "./core/di";
 export {
   AGENT_MODEL_PROVIDER,
-  Agent,
-  AgentRegistry,
+  AGENT_RUNTIME_OPTIONS,
   AgentRuntime,
   AgentRuntimeError,
   AgentSemanticError,
   AgentToolExecutionError,
-  AgentToolExecutor,
   ApproximateAgentContextTokenEstimator,
   DefaultAgentContextBuilder,
-  Prompt,
-  Task,
   Tool,
   agentClassSchema,
   agentData,
-  agentTaskMetadataOf,
   agentInvocation,
   agentJsonSchema,
   agentMessage,
   agentModelCapabilities,
   agentModelRequest,
   agentModelResponse,
-  agentOutput,
   agentOutputContract,
   agentText,
   agentToolCall,
   agentToolContract,
   agentToolResult,
-  collectAgentCatalog,
-  type AgentCatalog,
-  type AgentCatalogExtras,
   type AgentContext,
   type AgentContextBuildInput,
   type AgentContextBuilder,
   type AgentContextLimits,
   type AgentContextTokenEstimator,
   type AgentContextTraceEntry,
-  type AgentDefinition,
+  type AgentDataDefinition,
   type AgentInvocation,
   type AgentMessage,
-  type AgentMetadataIndex,
-  type AgentTaskDefinition,
-  type AgentTaskMetadata,
-  type AgentTaskOptions,
-  type TaskDecoratorOptions,
   type AgentModelCapabilities,
   type AgentModelRequest,
   type AgentModelResponse,
-  type AgentOptions,
   type AgentOutputContract,
   type AgentRuntimeInvokeOptions,
   type AgentRuntimeOptions,
   type AgentRuntimeResult,
   type AgentRuntimeStatus,
-  type AgentRuntimeTaskInvokeOptions,
   type AgentRuntimeToolExecutionOptions,
   type AgentToolCall,
   type AgentExecutableTool,
@@ -175,10 +159,7 @@ export {
   type AgentModelProvider,
   type AgentModelProviderContext,
   type JsonValue,
-  type PromptOptions,
-  type PromptSectionKind,
-  type PromptSectionMetadata,
-  type PromptSectionOptions,
+  type ToolDefinition,
   type ToolOptions,
 } from "./core/agent";
 export {

package/library/openapi/codegen.ts

@@ -461,12 +461,23 @@ export function createOpenApiCodegenAnalyzer(input: OpenApiCodegenAnalyzerInput)
   };
 
   const schemaFromArrayTsType = (type: ts.Type, seen: Set<string>): OpenApiCodegenSchema => {
-    if (checker.isTupleType(type)) {
-      const tupleArgs = typeArgumentsOf(type);
-      return { type: "array", items: mergeResponseSchemas(tupleArgs.map((item) => schemaFromTsType(item, seen))) ?? {} };
+    // A recursive alias can close its loop through an array without an object
+    // in between (`type Json = … | readonly Json[]`): the repeat is an untyped array.
+    const key = typeIdentity(type);
+    if (seen.has(key)) {
+      return { type: "array" };
+    }
+    seen.add(key);
+    try {
+      if (checker.isTupleType(type)) {
+        const tupleArgs = typeArgumentsOf(type);
+        return { type: "array", items: mergeResponseSchemas(tupleArgs.map((item) => schemaFromTsType(item, seen))) ?? {} };
+      }
+      const args = typeArgumentsOf(type);
+      return { type: "array", items: args[0] ? schemaFromTsType(args[0], seen) : {} };
+    } finally {
+      seen.delete(key);
     }
-    const args = typeArgumentsOf(type);
-    return { type: "array", items: args[0] ? schemaFromTsType(args[0], seen) : {} };
   };
 
   const schemaFromObjectTsType = (type: ts.Type, seen: Set<string>): OpenApiCodegenSchema => {

package/package.json

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

package/core/agent/decorators/Agent.ts

@@ -1,11 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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/generated/catalog.ts

@@ -1,26 +0,0 @@
-// This file is auto-generated by `bazis codegen`.
-// 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>([
-  ]),
-});