@autobe/agent 0.24.2 → 0.25.0

package/src/orchestrate/interface/orchestrateInterfaceOperations.ts

@@ -26,14 +26,16 @@ export async function orchestrateInterfaceOperations<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
+  props: {
+    instruction: string;
+    endpoints: AutoBeOpenApi.IEndpoint[];
+    capacity?: number;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const matrix: AutoBeOpenApi.IEndpoint[][] = divideArray({
-    array: endpoints,
-    capacity,
+    array: props.endpoints,
+    capacity: props.capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
-
   const progress: AutoBeProgressEventBase = {
     total: matrix.flat().length,
     completed: 0,
@@ -45,13 +47,13 @@ export async function orchestrateInterfaceOperations<
   return (
     await executeCachedBatch(
       matrix.map((it) => async (promptCacheKey) => {
-        const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(
-          ctx,
-          it,
+        const row: AutoBeOpenApi.IOperation[] = await divideAndConquer(ctx, {
+          endpoints: it,
           progress,
           reviewProgress,
           promptCacheKey,
-        );
+          instruction: props.instruction,
+        });
         return row;
       }),
     )
@@ -60,13 +62,16 @@ export async function orchestrateInterfaceOperations<
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: AutoBeOpenApi.IEndpoint[],
-  operationsProgress: AutoBeProgressEventBase,
-  operationsReviewProgress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    endpoints: AutoBeOpenApi.IEndpoint[];
+    progress: AutoBeProgressEventBase;
+    reviewProgress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const remained: HashSet<AutoBeOpenApi.IEndpoint> = new HashSet(
-    endpoints,
+    props.endpoints,
     OpenApiEndpointComparator.hashCode,
     OpenApiEndpointComparator.equals,
   );
@@ -76,9 +81,15 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
       OpenApiEndpointComparator.equals,
     );
   for (let i: number = 0; i < ctx.retry; ++i) {
-    if (remained.empty() === true || unique.size() >= endpoints.length) break;
+    if (remained.empty() === true || unique.size() >= props.endpoints.length)
+      break;
     const operations: AutoBeOpenApi.IOperation[] = remained.size()
-      ? await process(ctx, remained, operationsProgress, promptCacheKey)
+      ? await process(ctx, {
+          endpoints: remained,
+          progress: props.progress,
+          promptCacheKey: props.promptCacheKey,
+          instruction: props.instruction,
+        })
       : [];
 
     for (const item of operations) {
@@ -90,7 +101,7 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
     await orchestrateInterfaceOperationsReview(
       ctx,
       unique.toJSON().map((it) => it.second),
-      operationsReviewProgress,
+      props.reviewProgress,
     );
   for (const item of newbie) unique.set(item, item);
   return unique.toJSON().map((it) => it.second);
@@ -98,9 +109,12 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  endpoints: HashSet<AutoBeOpenApi.IEndpoint>,
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    endpoints: HashSet<AutoBeOpenApi.IEndpoint>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<AutoBeOpenApi.IOperation[]> {
   const prefix: string = NamingConvention.camel(ctx.state().analyze!.prefix);
   const pointer: IPointer<AutoBeOpenApi.IOperation[] | null> = {
@@ -108,10 +122,11 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceOperations",
-    histories: transformInterfaceOperationHistories(
-      ctx.state(),
-      endpoints.toJSON(),
-    ),
+    histories: transformInterfaceOperationHistories({
+      state: ctx.state(),
+      endpoints: props.endpoints.toJSON(),
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       roles: ctx.state().analyze?.roles.map((it) => it.name) ?? [],
@@ -143,10 +158,10 @@ async function process<Model extends ILlmSchema.Model>(
           }));
         });
         pointer.value.push(...matrix.flat());
-        progress.completed += matrix.flat().length;
-        progress.total += operations
+        props.progress.completed += matrix.flat().length;
+        props.progress.total += operations
           .map((op) =>
-            endpoints.has({ path: op.path, method: op.method })
+            props.endpoints.has({ path: op.path, method: op.method })
               ? op.authorizationRoles.length === 0
                 ? 0
                 : op.authorizationRoles.length - 1
@@ -156,7 +171,7 @@ async function process<Model extends ILlmSchema.Model>(
       },
     }),
     enforceFunctionCall: true,
-    promptCacheKey,
+    promptCacheKey: props.promptCacheKey,
     message: "Make API operations",
   });
   if (pointer.value === null) throw new Error("Failed to create operations."); // never be happened
@@ -166,7 +181,7 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     operations: pointer.value,
     tokenUsage,
-    ...progress,
+    ...props.progress,
     step: ctx.state().analyze?.step ?? 0,
     created_at: new Date().toISOString(),
   } satisfies AutoBeInterfaceOperationsEvent);

package/src/orchestrate/interface/orchestrateInterfaceSchemas.ts

@@ -27,15 +27,18 @@ export async function orchestrateInterfaceSchemas<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  capacity: number = AutoBeConfigConstant.INTERFACE_CAPACITY,
+  props: {
+    operations: AutoBeOpenApi.IOperation[];
+    instruction: string;
+    capacity?: number;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
   // fix operation type names
-  JsonSchemaNamingConvention.operations(operations);
+  JsonSchemaNamingConvention.operations(props.operations);
 
   // gather type names
   const typeNames: Set<string> = new Set();
-  for (const op of operations) {
+  for (const op of props.operations) {
     if (op.requestBody !== null) typeNames.add(op.requestBody.typeName);
     if (op.responseBody !== null) typeNames.add(op.responseBody.typeName);
   }
@@ -45,7 +48,7 @@ export async function orchestrateInterfaceSchemas<
   // divide and conquer
   const matrix: string[][] = divideArray({
     array: Array.from(typeNames),
-    capacity,
+    capacity: props.capacity ?? AutoBeConfigConstant.INTERFACE_CAPACITY,
   });
   const progress: AutoBeProgressEventBase = {
     total: typeNames.size,
@@ -57,39 +60,48 @@ export async function orchestrateInterfaceSchemas<
   for (const y of await executeCachedBatch(
     matrix.map((it) => async (promptCacheKey) => {
       const row: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-        await divideAndConquer(ctx, operations, it, progress, promptCacheKey);
+        await divideAndConquer(ctx, {
+          instruction: props.instruction,
+          operations: props.operations,
+          typeNames: it,
+          progress,
+          promptCacheKey,
+        });
       return row;
     }),
   )) {
-    JsonSchemaNamingConvention.schemas(operations, x, y);
+    JsonSchemaNamingConvention.schemas(props.operations, x, y);
     Object.assign(x, y);
   }
   Object.assign(x, presets);
-  JsonSchemaNamingConvention.schemas(operations, x);
+  JsonSchemaNamingConvention.schemas(props.operations, x);
   JsonSchemaFactory.authorize(x);
   return x;
 }
 
 async function divideAndConquer<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  typeNames: string[],
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    operations: AutoBeOpenApi.IOperation[];
+    typeNames: string[];
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const remained: Set<string> = new Set(typeNames);
+  const remained: Set<string> = new Set(props.typeNames);
   const schemas: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> = {};
   for (let i: number = 0; i < ctx.retry; ++i) {
     if (remained.size === 0) break;
     const newbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive> =
-      await process(
-        ctx,
-        operations,
-        schemas,
+      await process(ctx, {
+        instruction: props.instruction,
+        operations: props.operations,
+        promptCacheKey: props.promptCacheKey,
+        progress: props.progress,
+        oldbie: schemas,
         remained,
-        progress,
-        promptCacheKey,
-      );
+      });
     for (const key of Object.keys(newbie)) {
       schemas[key] = newbie[key];
       remained.delete(key);
@@ -100,13 +112,16 @@ async function divideAndConquer<Model extends ILlmSchema.Model>(
 
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
-  operations: AutoBeOpenApi.IOperation[],
-  oldbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>,
-  remained: Set<string>,
-  progress: AutoBeProgressEventBase,
-  promptCacheKey: string,
+  props: {
+    operations: AutoBeOpenApi.IOperation[];
+    oldbie: Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>;
+    remained: Set<string>;
+    progress: AutoBeProgressEventBase;
+    promptCacheKey: string;
+    instruction: string;
+  },
 ): Promise<Record<string, AutoBeOpenApi.IJsonSchemaDescriptive>> {
-  const already: string[] = Object.keys(oldbie);
+  const already: string[] = Object.keys(props.oldbie);
   const pointer: IPointer<Record<
     string,
     AutoBeOpenApi.IJsonSchemaDescriptive
@@ -115,7 +130,11 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "interfaceSchemas",
-    histories: transformInterfaceSchemaHistories(ctx.state(), operations),
+    histories: transformInterfaceSchemaHistories({
+      state: ctx.state(),
+      operations: props.operations,
+      instruction: props.instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: async (next) => {
@@ -125,7 +144,7 @@ async function process<Model extends ILlmSchema.Model>(
       pointer,
     }),
     enforceFunctionCall: true,
-    promptCacheKey,
+    promptCacheKey: props.promptCacheKey,
     message: StringUtil.trim`
       Make type components please.
 
@@ -134,7 +153,7 @@ async function process<Model extends ILlmSchema.Model>(
       types are required during making the components, please make them
       too.
 
-      ${Array.from(remained)
+      ${Array.from(props.remained)
         .map((k) => `      - \`${k}\``)
         .join("\n")}${
         already.length !== 0
@@ -161,9 +180,9 @@ async function process<Model extends ILlmSchema.Model>(
     id: v7(),
     schemas,
     tokenUsage,
-    completed: (progress.completed += Object.keys(schemas).length),
-    total: (progress.total += Object.keys(schemas).filter(
-      (k) => remained.has(k) === false,
+    completed: (props.progress.completed += Object.keys(schemas).length),
+    total: (props.progress.total += Object.keys(schemas).filter(
+      (k) => props.remained.has(k) === false,
     ).length),
     step: ctx.state().prisma?.step ?? 0,
     created_at: new Date().toISOString(),

package/src/orchestrate/prisma/histories/transformPrismaComponentsHistories.ts

@@ -8,14 +8,17 @@ import { AutoBeState } from "../../../context/AutoBeState";
 
 export const transformPrismaComponentsHistories = (
   state: AutoBeState,
-  prefix: string | null = null,
+  props: {
+    prefix: string | null;
+    instruction: string;
+  },
 ): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   if (state.analyze === null)
     // unreachable
     throw new Error("Analyze state is not set.");
-  if (prefix) prefix = NamingConvention.snake(prefix);
+  if (props.prefix) props.prefix = NamingConvention.snake(props.prefix);
   return [
     {
       id: v7(),
@@ -28,20 +31,20 @@ export const transformPrismaComponentsHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
+        ## Requirement Analysis Report
+
         Here is the requirement analysis report.
         
         Call the provided tool function to generate Prisma DB schema
         referencing below requirement analysis report.
         
-        ## Requirement Analysis Report
-        
         \`\`\`json
         ${JSON.stringify(state.analyze.files)}
         \`\`\`
         
         ## Prefix
         
-        - Prefix provided by the user: ${prefix}
+        - Prefix provided by the user: ${props.prefix}
         
         The user wants all database schema (table) names to start with the prefix provided below.
         
@@ -74,11 +77,22 @@ export const transformPrismaComponentsHistories = (
                 Create separate tables for each role:
                 
                 ${state.analyze.roles
-                  .map((role) => `- ${prefix}_${role.name.toLowerCase()}`)
+                  .map((role) => `- ${props.prefix}_${role.name.toLowerCase()}`)
                   .join("\n")}
               `
             : ""
         }
+
+        ## Database Design Instructions
+
+        The following database-specific instructions were extracted by AI from
+        the user's utterances. These focus ONLY on database schema design aspects
+        such as table structure, relationships, constraints, and indexing strategies.
+
+        Reference these instructions when designing namespace components and 
+        DB table names.
+
+        ${props.instruction}
       `,
     },
   ];

package/src/orchestrate/prisma/histories/transformPrismaSchemaHistories.ts

@@ -5,11 +5,12 @@ import { v7 } from "uuid";
 
 import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
 
-export const transformPrismaSchemaHistories = (
-  requirementAnalysisReport: Record<string, string>,
-  targetComponent: AutoBePrisma.IComponent,
-  otherTables: string[],
-): Array<
+export const transformPrismaSchemaHistories = (props: {
+  analysis: Record<string, string>;
+  targetComponent: AutoBePrisma.IComponent;
+  otherTables: string[];
+  instruction: string;
+}): Array<
   IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
 > => {
   return [
@@ -27,7 +28,7 @@ export const transformPrismaSchemaHistories = (
         Here is the requirement analysis report:
 
         \`\`\`json
-        ${JSON.stringify(requirementAnalysisReport)}
+        ${JSON.stringify(props.analysis)}
         \`\`\`
       `,
     },
@@ -36,12 +37,26 @@ export const transformPrismaSchemaHistories = (
       created_at: new Date().toISOString(),
       type: "assistantMessage",
       text: StringUtil.trim`
+        ## Database Design Instructions
+
+        The following database-specific instructions were extracted by AI from
+        the user's utterances. These focus ONLY on database schema design aspects
+        such as table structure, relationships, constraints, and indexing strategies.
+
+        Reference these instructions when designing the DB schema for this specific
+        component. If the instruction is not related to the current domain or
+        component, you may ignore it.
+
+        ${props.instruction}
+
+        ## Target Component
+        
         Here is the input data for generating Prisma DB schema.
         
         \`\`\`json
         ${JSON.stringify({
-          targetComponent,
-          otherTables,
+          targetComponent: props.targetComponent,
+          otherTables: props.otherTables,
         })}
         \`\`\`
       `,
@@ -58,7 +73,7 @@ export const transformPrismaSchemaHistories = (
         
         \`\`\`json
         ${JSON.stringify({
-          targetComponent,
+          targetComponent: props.targetComponent,
         })}
         \`\`\`
       `,

package/src/orchestrate/prisma/orchestratePrisma.ts

@@ -39,18 +39,22 @@ export const orchestratePrisma = async <Model extends ILlmSchema.Model>(
     type: "prismaStart",
     id: v7(),
     created_at: start.toISOString(),
-    reason: props.reason,
+    reason: props.instruction,
     step: ctx.state().analyze?.step ?? 0,
   });
 
   // COMPONENTS
   const componentEvent: AutoBePrismaComponentsEvent =
-    await orchestratePrismaComponents(ctx);
+    await orchestratePrismaComponents(ctx, props.instruction);
   ctx.dispatch(componentEvent);
 
   // CONSTRUCT AST DATA
   const schemaEvents: AutoBePrismaSchemasEvent[] =
-    await orchestratePrismaSchemas(ctx, componentEvent.components);
+    await orchestratePrismaSchemas(
+      ctx,
+      props.instruction,
+      componentEvent.components,
+    );
   const application: AutoBePrisma.IApplication = {
     files: schemaEvents.map((e) => e.file),
   };

package/src/orchestrate/prisma/orchestratePrismaComponent.ts

@@ -14,6 +14,7 @@ export async function orchestratePrismaComponents<
   Model extends ILlmSchema.Model,
 >(
   ctx: AutoBeContext<Model>,
+  instruction: string,
   message: string = "Design database from the given requirement analysis documents.",
 ): Promise<AutoBePrismaComponentsEvent> {
   const start: Date = new Date();
@@ -23,7 +24,10 @@ export async function orchestratePrismaComponents<
   const prefix: string | null = ctx.state().analyze?.prefix ?? null;
   const { tokenUsage } = await ctx.conversate({
     source: "prismaComponents",
-    histories: transformPrismaComponentsHistories(ctx.state(), prefix),
+    histories: transformPrismaComponentsHistories(ctx.state(), {
+      prefix,
+      instruction,
+    }),
     controller: createController({
       model: ctx.model,
       build: (next) => {

package/src/orchestrate/prisma/orchestratePrismaSchemas.ts

@@ -15,6 +15,7 @@ import { IAutoBePrismaSchemaApplication } from "./structures/IAutoBePrismaSchema
 
 export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
+  instruction: string,
   componentList: AutoBePrisma.IComponent[],
 ): Promise<AutoBePrismaSchemasEvent[]> {
   const start: Date = new Date();
@@ -29,6 +30,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
         .map((c) => c.tables)
         .flat();
       const event: AutoBePrismaSchemasEvent = await process(ctx, {
+        instruction,
         component,
         otherTables,
         start,
@@ -45,6 +47,7 @@ export async function orchestratePrismaSchemas<Model extends ILlmSchema.Model>(
 async function process<Model extends ILlmSchema.Model>(
   ctx: AutoBeContext<Model>,
   props: {
+    instruction: string;
     component: AutoBePrisma.IComponent;
     otherTables: string[];
     start: Date;
@@ -58,16 +61,18 @@ async function process<Model extends ILlmSchema.Model>(
   };
   const { tokenUsage } = await ctx.conversate({
     source: "prismaSchemas",
-    histories: transformPrismaSchemaHistories(
-      ctx
-        .state()
-        .analyze?.files.map((file) => ({ [file.filename]: file.content }))
-        .reduce((acc, cur) => {
-          return Object.assign(acc, cur);
-        }, {}) ?? {},
-      props.component,
-      props.otherTables,
-    ),
+    histories: transformPrismaSchemaHistories({
+      analysis:
+        ctx
+          .state()
+          .analyze?.files.map((file) => ({ [file.filename]: file.content }))
+          .reduce((acc, cur) => {
+            return Object.assign(acc, cur);
+          }, {}) ?? {},
+      targetComponent: props.component,
+      otherTables: props.otherTables,
+      instruction: props.instruction,
+    }),
     controller: createController(ctx, {
       targetComponent: props.component,
       otherTables: props.otherTables,

package/src/orchestrate/realize/histories/transformRealizeCorrectCastingHistories.ts

@@ -0,0 +1,45 @@
+import { IAgenticaHistoryJson } from "@agentica/core";
+import { IAutoBeTypeScriptCompileResult } from "@autobe/interface";
+import { StringUtil } from "@autobe/utils";
+import { v7 } from "uuid";
+
+import { AutoBeSystemPromptConstant } from "../../../constants/AutoBeSystemPromptConstant";
+
+interface IFailure {
+  diagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[];
+  script: string;
+}
+
+export const transformRealizeCorrectCastingHistories = (
+  failures: IFailure[],
+): Array<
+  IAgenticaHistoryJson.IAssistantMessage | IAgenticaHistoryJson.ISystemMessage
+> => {
+  return [
+    {
+      id: v7(),
+      created_at: new Date().toISOString(),
+      type: "systemMessage",
+      text: AutoBeSystemPromptConstant.REALIZE_CORRECT_CASTING,
+    },
+    ...failures.map(
+      (f, i, array) =>
+        ({
+          id: v7(),
+          created_at: new Date().toISOString(),
+          type: "assistantMessage",
+          text: StringUtil.trim`
+          # ${i === array.length - 1 ? "Latest Failure" : "Previous Failure"}
+          ## Generated TypeScript Code
+          \`\`\`typescript
+          ${f.script}
+          \`\`\`
+          ## Compile Errors
+          \`\`\`json
+          ${JSON.stringify(f.diagnostics)}
+          \`\`\`
+        `,
+        }) satisfies IAgenticaHistoryJson.IAssistantMessage,
+    ),
+  ];
+};

package/src/orchestrate/realize/orchestRateRealizeCorrectCasting.ts

@@ -14,8 +14,8 @@ import { v7 } from "uuid";
 import { AutoBeContext } from "../../context/AutoBeContext";
 import { assertSchemaModel } from "../../context/assertSchemaModel";
 import { executeCachedBatch } from "../../utils/executeCachedBatch";
-import { transformCommonCorrectCastingHistories } from "../common/histories/transformCommonCorrectCastingHistories";
 import { IAutoBeCommonCorrectCastingApplication } from "../common/structures/IAutoBeCommonCorrectCastingApplication";
+import { transformRealizeCorrectCastingHistories } from "./histories/transformRealizeCorrectCastingHistories";
 import { compileRealizeFiles } from "./internal/compileRealizeFiles";
 
 /** Result of attempting to correct a single function */
@@ -94,6 +94,12 @@ const correct = async <Model extends ILlmSchema.Model>(
   const locations: string[] = diagnose(event).filter((l) =>
     functions.map((f) => f.location).includes(l),
   );
+  
+  // If no locations to correct, return original functions
+  if (locations.length === 0) {
+    return functions;
+  }
+  
   progress.total += locations.length;
 
   const converted: CorrectionResult[] = await executeCachedBatch(
@@ -110,7 +116,7 @@ const correct = async <Model extends ILlmSchema.Model>(
 
       const { tokenUsage } = await ctx.conversate({
         source: "realizeCorrect",
-        histories: transformCommonCorrectCastingHistories([
+        histories: transformRealizeCorrectCastingHistories([
           {
             script: func.content,
             diagnostics: failures.filter((d) => d.file === location),
@@ -172,7 +178,18 @@ const correct = async <Model extends ILlmSchema.Model>(
     },
   );
 
-  if (newValidate.result.type === "success") {
+  const newResult: IAutoBeTypeScriptCompileResult = newValidate.result;
+  if (newResult.type === "success") {
+    return converted.map((c) => c.func);
+  } else if (newResult.type === "exception") {
+    // Compilation exception, return current functions. because retrying won't help.
+    return functions;
+  }
+
+  if (
+    newResult.diagnostics.every((d) => !d.file?.startsWith("src/providers"))
+  ) {
+    // No diagnostics related to provider functions, stop correcting
     return converted.map((c) => c.func);
   }
 
@@ -193,9 +210,7 @@ const correct = async <Model extends ILlmSchema.Model>(
   const failedLocations: string[] = failed.map((f) => f.location);
   const allDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] = [
     ...failures,
-    ...(newValidate.result.type === "failure"
-      ? newValidate.result.diagnostics
-      : []),
+    ...(newResult.type === "failure" ? newResult.diagnostics : []),
   ];
   const relevantDiagnostics: IAutoBeTypeScriptCompileResult.IDiagnostic[] =
     filterRelevantDiagnostics(allDiagnostics, failedLocations);
@@ -211,7 +226,11 @@ const correct = async <Model extends ILlmSchema.Model>(
     life - 1,
   );
 
-  return [...success, ...ignored, ...retriedFunctions];
+  // Get functions that were not modified (not in converted array)
+  const convertedLocations = converted.map(c => c.func.location);
+  const unchanged = functions.filter(f => !convertedLocations.includes(f.location));
+
+  return [...success, ...ignored, ...retriedFunctions, ...unchanged];
 };
 
 /**