@autobe/agent
Version:
AI backend server code generator
800 lines • 81 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.orchestrateRealizeCorrect = orchestrateRealizeCorrect;
const __typia_transform__validateReport = __importStar(require("typia/lib/internal/_validateReport.js"));
const __typia_transform__llmApplicationFinalize = __importStar(require("typia/lib/internal/_llmApplicationFinalize.js"));
const typia_1 = __importDefault(require("typia"));
const uuid_1 = require("uuid");
const assertSchemaModel_1 = require("../../context/assertSchemaModel");
const executeCachedBatch_1 = require("../../utils/executeCachedBatch");
const validateEmptyCode_1 = require("../../utils/validateEmptyCode");
const AutoBePreliminaryController_1 = require("../common/AutoBePreliminaryController");
const transformRealizeCorrectHistory_1 = require("./histories/transformRealizeCorrectHistory");
const compileRealizeFiles_1 = require("./internal/compileRealizeFiles");
const filterDiagnostics_1 = require("./utils/filterDiagnostics");
const getRealizeWriteDto_1 = require("./utils/getRealizeWriteDto");
const replaceImportStatements_1 = require("./utils/replaceImportStatements");
function orchestrateRealizeCorrect(ctx_1, scenarios_1, authorizations_1, functions_1, previousFailures_1, progress_1) {
return __awaiter(this, arguments, void 0, function* (ctx, scenarios, authorizations, functions, previousFailures, progress, life = ctx.retry) {
const event = yield (0, compileRealizeFiles_1.compileRealizeFiles)(ctx, {
authorizations,
functions,
});
if (event.result.type !== "failure")
return functions;
else if (life < 0)
return functions;
// Extract and process diagnostics
const diagnostics = event.result.diagnostics;
if (event.result.diagnostics.every((d) => { var _a; return !((_a = d.file) === null || _a === void 0 ? void 0 : _a.startsWith("src/providers")); }) === true) {
// No diagnostics related to provider functions, stop correcting
return functions;
}
const locations = Array.from(new Set(diagnostics
.map((d) => d.file)
.filter((f) => f !== null)
.filter((f) => f.startsWith("src/providers"))));
progress.total += locations.length;
// Group diagnostics by file and add to failures
const diagnosticsByFile = {};
diagnostics.forEach((diagnostic) => {
const location = diagnostic.file;
if (location === null)
return;
if (!location.startsWith("src/providers"))
return;
if (!diagnosticsByFile[location]) {
const func = functions.find((f) => f.location === location);
if (func === undefined) {
return;
}
const failure = {
function: func,
diagnostics: [],
};
diagnosticsByFile[location] = failure;
}
diagnosticsByFile[location].diagnostics.push(diagnostic);
});
const newFailures = Object.values(diagnosticsByFile);
const corrected = yield correct(ctx, {
locations,
scenarios,
authorizations,
functions,
previousFailures,
failures: (0, filterDiagnostics_1.filterDiagnostics)(newFailures, functions.map((fn) => fn.location)),
progress,
});
return orchestrateRealizeCorrect(ctx, scenarios, authorizations, corrected, [...previousFailures, newFailures], progress, life - 1);
});
}
function correct(ctx, props) {
return __awaiter(this, void 0, void 0, function* () {
if (props.locations.length === 0) {
return props.functions;
}
const corrected = yield (0, executeCachedBatch_1.executeCachedBatch)(ctx, props.locations.map((location) => () => __awaiter(this, void 0, void 0, function* () {
var _a;
const scenario = props.scenarios.find((el) => el.location === location);
const func = props.functions.find((el) => el.location === location);
if (!func) {
throw new Error("No function found for location: " + location);
}
const failures = props.failures.filter((f) => { var _a; return ((_a = f.function) === null || _a === void 0 ? void 0 : _a.location) === location; });
if (failures.length && scenario) {
try {
const correctEvent = yield step(ctx, {
totalAuthorizations: props.authorizations,
authorization: (_a = scenario.decoratorEvent) !== null && _a !== void 0 ? _a : null,
scenario,
function: func,
previousFailures: props.previousFailures
.map((pf) => {
const previousFailures = pf.filter((f) => f.function.location === location);
if (previousFailures.length === 0)
return null;
return {
function: previousFailures[0].function,
diagnostics: previousFailures
.map((f) => f.diagnostics)
.flat(),
};
})
.filter((f) => f !== null),
failure: {
function: failures[0].function,
diagnostics: failures.map((f) => f.diagnostics).flat(),
},
progress: props.progress,
});
return Object.assign(Object.assign({}, func), { content: correctEvent === null ? "" : correctEvent.content });
}
catch (err) {
return func;
}
}
return func;
})));
// Create a map of corrected functions for efficient lookup
const correctedMap = new Map(corrected.map((f) => [f.location, f]));
// Return all functions, with corrected ones replaced
return props.functions.map((func) => correctedMap.get(func.location) || func);
});
}
function step(ctx, props) {
return __awaiter(this, void 0, void 0, function* () {
const dto = yield (0, getRealizeWriteDto_1.getRealizeWriteDto)(ctx, props.scenario.operation);
const preliminary = new AutoBePreliminaryController_1.AutoBePreliminaryController({
source: SOURCE,
application: {
version: "3.1",
components: {
schemas: {
"IAutoBeRealizeCorrectApplication.IProps": {
type: "object",
properties: {
thinking: {
type: "string",
description: "Think before you act.\n\nBefore requesting preliminary data or completing your task, reflect on your\ncurrent state and explain your reasoning:\n\nFor preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):\n- What critical information is missing that you don't already have?\n- Why do you need it specifically right now?\n- Be brief - state the gap, don't list everything you have.\n\nFor completion (complete):\n- What key assets did you acquire?\n- What did you accomplish?\n- Why is it sufficient to complete?\n- Summarize - don't enumerate every single item.\n\nThis reflection helps you avoid duplicate requests and premature completion."
},
request: {
oneOf: [
{
$ref: "#/components/schemas/IAutoBePreliminaryGetPrismaSchemas"
},
{
$ref: "#/components/schemas/IAutoBeRealizeCorrectApplication.IComplete"
}
],
discriminator: {
propertyName: "type",
mapping: {
getPrismaSchemas: "#/components/schemas/IAutoBePreliminaryGetPrismaSchemas",
complete: "#/components/schemas/IAutoBeRealizeCorrectApplication.IComplete"
}
},
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval\n(getPrismaSchemas) or final error correction (complete). When preliminary\nreturns empty array, that type is removed from the union, physically\npreventing repeated calls."
}
},
required: [
"thinking",
"request"
]
},
IAutoBePreliminaryGetPrismaSchemas: {
type: "object",
properties: {
type: {
"const": "getPrismaSchemas",
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval or actual\ntask execution. Value \"getPrismaSchemas\" indicates this is a preliminary\ndata request for Prisma schemas."
},
schemaNames: {
type: "array",
items: {
type: "string"
},
minItems: 1,
description: "List of Prisma table names to retrieve.\n\nTable names from the Prisma schema file representing database entities\n(e.g., \"user\", \"post\", \"comment\").\n\nCRITICAL: DO NOT request the same schema names that you have already\nrequested in previous calls."
}
},
required: [
"type",
"schemaNames"
],
description: "Request to retrieve Prisma database schema definitions for context.\n\nThis type is used in the preliminary phase to request specific Prisma table\nschemas needed for generating type-safe API operations."
},
"IAutoBeRealizeCorrectApplication.IComplete": {
type: "object",
properties: {
type: {
"const": "complete",
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval or actual\ntask execution. Value \"complete\" indicates this is the final task\nexecution request."
},
think: {
type: "string",
description: "Initial error analysis and correction strategy.\n\nAnalyzes TypeScript compilation errors to understand:\n\n- Error patterns and root causes\n- Required fixes and their impact\n- Whether quick fixes or deep refactoring is needed\n- Prisma schema and API contract constraints"
},
draft: {
type: "string",
description: "First correction attempt.\n\nImplements the initial fixes identified in the think phase. For simple\nerrors (typos, missing imports), this may be the final solution. Complex\nerrors may require further refinement."
},
revise: {
$ref: "#/components/schemas/IAutoBeRealizeCorrectApplication.IReviseProps",
description: "Revision and finalization phase.\n\nReviews the draft corrections and produces the final, error-free code\nthat maintains all business requirements."
}
},
required: [
"type",
"think",
"draft",
"revise"
],
description: "Request to correct provider implementation errors.\n\nExecutes three-phase error correction to resolve TypeScript compilation\nissues in provider functions. Applies systematic fixes following think \u2192\ndraft \u2192 revise pattern to ensure error-free production code."
},
"IAutoBeRealizeCorrectApplication.IReviseProps": {
type: "object",
properties: {
review: {
type: "string",
description: "Correction review and validation.\n\nAnalyzes the draft corrections to ensure:\n\n- All TypeScript errors are resolved\n- Business logic remains intact\n- AutoBE coding standards are maintained\n- No new errors are introduced\n- Performance and security are preserved"
},
final: {
oneOf: [
{
type: "null"
},
{
type: "string"
}
],
description: "Final error-free implementation.\n\nThe complete, corrected code that passes all TypeScript compilation\nchecks.\n\nReturns `null` if the draft corrections are sufficient and need no\nfurther changes."
}
},
required: [
"review",
"final"
]
}
}
},
functions: [
{
name: "process",
async: false,
parameters: [
{
name: "props",
description: " Request containing either preliminary data request or complete\ntask",
required: true,
schema: {
$ref: "#/components/schemas/IAutoBeRealizeCorrectApplication.IProps"
}
}
],
description: "Process provider correction task or preliminary data requests.\n\nSystematically analyzes and corrects TypeScript compilation errors through\nthree-phase workflow (think \u2192 draft \u2192 revise). Maintains business logic\nintegrity while resolving all compilation issues."
}
]
},
kinds: ["prismaSchemas"],
state: ctx.state(),
});
return yield preliminary.orchestrate(ctx, (out) => __awaiter(this, void 0, void 0, function* () {
var _a, _b, _c, _d, _e;
const pointer = {
value: null,
};
const result = yield ctx.conversate(Object.assign({ source: "realizeCorrect", controller: createController({
model: ctx.model,
functionName: props.scenario.functionName,
build: (next) => {
pointer.value = next;
},
preliminary,
}), enforceFunctionCall: true }, (0, transformRealizeCorrectHistory_1.transformRealizeCorrectHistory)(ctx, {
state: ctx.state(),
scenario: props.scenario,
authorization: props.authorization,
function: props.function,
dto,
failures: [...props.previousFailures, props.failure],
totalAuthorizations: props.totalAuthorizations,
preliminary,
})));
if (pointer.value !== null) {
pointer.value.draft = yield (0, replaceImportStatements_1.replaceImportStatements)(ctx, {
operation: props.scenario.operation,
schemas: ctx.state().interface.document.components.schemas,
code: pointer.value.draft,
decoratorType: (_a = props.authorization) === null || _a === void 0 ? void 0 : _a.payload.name,
});
if (pointer.value.revise.final)
pointer.value.revise.final = yield (0, replaceImportStatements_1.replaceImportStatements)(ctx, {
operation: props.scenario.operation,
schemas: ctx.state().interface.document.components.schemas,
code: pointer.value.revise.final,
decoratorType: (_b = props.authorization) === null || _b === void 0 ? void 0 : _b.payload.name,
});
const event = {
type: "realizeCorrect",
kind: "overall",
id: (0, uuid_1.v7)(),
location: props.scenario.location,
content: (_c = pointer.value.revise.final) !== null && _c !== void 0 ? _c : pointer.value.draft,
metric: result.metric,
tokenUsage: result.tokenUsage,
completed: ++props.progress.completed,
total: props.progress.total,
step: (_e = (_d = ctx.state().analyze) === null || _d === void 0 ? void 0 : _d.step) !== null && _e !== void 0 ? _e : 0,
created_at: new Date().toISOString(),
};
ctx.dispatch(event);
return out(result)(event);
}
return out(result)(null);
}));
});
}
function createController(props) {
(0, assertSchemaModel_1.assertSchemaModel)(props.model);
const validate = (input) => {
const result = (() => { const _io0 = input => "string" === typeof input.thinking && ("object" === typeof input.request && null !== input.request && _iu0(input.request)); const _io1 = input => "getPrismaSchemas" === input.type && (Array.isArray(input.schemaNames) && (1 <= input.schemaNames.length && input.schemaNames.every(elem => "string" === typeof elem))); const _io2 = input => "complete" === input.type && "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io3(input.revise)); const _io3 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final); const _iu0 = input => (() => {
if ("getPrismaSchemas" === input.type)
return _io1(input);
else if ("complete" === input.type)
return _io2(input);
else
return false;
})(); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
path: _path + ".thinking",
expected: "string",
value: input.thinking
}), ("object" === typeof input.request && null !== input.request || _report(_exceptionable, {
path: _path + ".request",
expected: "(IAutoBePreliminaryGetPrismaSchemas | IAutoBeRealizeCorrectApplication.IComplete)",
value: input.request
})) && _vu0(input.request, _path + ".request", true && _exceptionable) || _report(_exceptionable, {
path: _path + ".request",
expected: "(IAutoBePreliminaryGetPrismaSchemas | IAutoBeRealizeCorrectApplication.IComplete)",
value: input.request
})].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["getPrismaSchemas" === input.type || _report(_exceptionable, {
path: _path + ".type",
expected: "\"getPrismaSchemas\"",
value: input.type
}), (Array.isArray(input.schemaNames) || _report(_exceptionable, {
path: _path + ".schemaNames",
expected: "(Array<string> & MinItems<1>)",
value: input.schemaNames
})) && ((1 <= input.schemaNames.length || _report(_exceptionable, {
path: _path + ".schemaNames",
expected: "Array<> & MinItems<1>",
value: input.schemaNames
})) && input.schemaNames.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
path: _path + ".schemaNames[" + _index2 + "]",
expected: "string",
value: elem
})).every(flag => flag)) || _report(_exceptionable, {
path: _path + ".schemaNames",
expected: "(Array<string> & MinItems<1>)",
value: input.schemaNames
})].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["complete" === input.type || _report(_exceptionable, {
path: _path + ".type",
expected: "\"complete\"",
value: input.type
}), "string" === typeof input.think || _report(_exceptionable, {
path: _path + ".think",
expected: "string",
value: input.think
}), "string" === typeof input.draft || _report(_exceptionable, {
path: _path + ".draft",
expected: "string",
value: input.draft
}), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
path: _path + ".revise",
expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
value: input.revise
})) && _vo3(input.revise, _path + ".revise", true && _exceptionable) || _report(_exceptionable, {
path: _path + ".revise",
expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
value: input.revise
})].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.review || _report(_exceptionable, {
path: _path + ".review",
expected: "string",
value: input.review
}), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
path: _path + ".final",
expected: "(null | string)",
value: input.final
})].every(flag => flag); const _vu0 = (input, _path, _exceptionable = true) => (() => {
if ("getPrismaSchemas" === input.type)
return _vo1(input, _path, true && _exceptionable);
else if ("complete" === input.type)
return _vo2(input, _path, true && _exceptionable);
else
return _report(_exceptionable, {
path: _path,
expected: "(IAutoBePreliminaryGetPrismaSchemas | IAutoBeRealizeCorrectApplication.IComplete)",
value: input
});
})(); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
if (false === __is(input)) {
errors = [];
_report = __typia_transform__validateReport._validateReport(errors);
((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
path: _path + "",
expected: "IAutoBeRealizeCorrectApplication.IProps",
value: input
})) && _vo0(input, _path + "", true) || _report(true, {
path: _path + "",
expected: "IAutoBeRealizeCorrectApplication.IProps",
value: input
}))(input, "$input", true);
const success = 0 === errors.length;
return success ? {
success,
data: input
} : {
success,
errors,
data: input
};
}
return {
success: true,
data: input
};
}; })()(input);
if (result.success === false)
return result;
else if (result.data.request.type !== "complete")
return props.preliminary.validate({
thinking: result.data.thinking,
request: result.data.request,
});
const errors = (0, validateEmptyCode_1.validateEmptyCode)({
functionName: props.functionName,
draft: result.data.request.draft,
revise: result.data.request.revise,
});
return errors.length
? {
success: false,
errors,
data: result.data,
}
: result;
};
const application = collection[props.model === "chatgpt"
? "chatgpt"
: props.model === "gemini"
? "gemini"
: "claude"](validate);
return {
protocol: "class",
name: SOURCE,
application,
execute: {
process: (next) => {
if (next.request.type === "complete")
props.build(next.request);
},
},
};
}
const collection = {
chatgpt: (validate) => (() => {
const application = {
model: "chatgpt",
options: {
reference: true,
strict: false,
separate: null
},
functions: [
{
name: "process",
parameters: {
description: " Request containing either preliminary data request or complete\ntask\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeCorrectApplication.IProps}",
type: "object",
properties: {
thinking: {
description: "Think before you act.\n\nBefore requesting preliminary data or completing your task, reflect on your\ncurrent state and explain your reasoning:\n\nFor preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):\n- What critical information is missing that you don't already have?\n- Why do you need it specifically right now?\n- Be brief - state the gap, don't list everything you have.\n\nFor completion (complete):\n- What key assets did you acquire?\n- What did you accomplish?\n- Why is it sufficient to complete?\n- Summarize - don't enumerate every single item.\n\nThis reflection helps you avoid duplicate requests and premature completion.",
type: "string"
},
request: {
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval\n(getPrismaSchemas) or final error correction (complete). When preliminary\nreturns empty array, that type is removed from the union, physically\npreventing repeated calls.",
anyOf: [
{
$ref: "#/$defs/IAutoBePreliminaryGetPrismaSchemas"
},
{
$ref: "#/$defs/IAutoBeRealizeCorrectApplication.IComplete"
}
],
"x-discriminator": {
propertyName: "type",
mapping: {
getPrismaSchemas: "#/$defs/IAutoBePreliminaryGetPrismaSchemas",
complete: "#/$defs/IAutoBeRealizeCorrectApplication.IComplete"
}
}
}
},
required: [
"thinking",
"request"
],
additionalProperties: false,
$defs: {
IAutoBePreliminaryGetPrismaSchemas: {
description: "Request to retrieve Prisma database schema definitions for context.\n\nThis type is used in the preliminary phase to request specific Prisma table\nschemas needed for generating type-safe API operations.",
type: "object",
properties: {
type: {
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval or actual\ntask execution. Value \"getPrismaSchemas\" indicates this is a preliminary\ndata request for Prisma schemas.",
type: "string",
"enum": [
"getPrismaSchemas"
]
},
schemaNames: {
description: "List of Prisma table names to retrieve.\n\nTable names from the Prisma schema file representing database entities\n(e.g., \"user\", \"post\", \"comment\").\n\nCRITICAL: DO NOT request the same schema names that you have already\nrequested in previous calls.\n\n\n@minItems 1",
type: "array",
items: {
type: "string"
}
}
},
required: [
"type",
"schemaNames"
]
},
"IAutoBeRealizeCorrectApplication.IComplete": {
description: "Request to correct provider implementation errors.\n\nExecutes three-phase error correction to resolve TypeScript compilation\nissues in provider functions. Applies systematic fixes following think \u2192\ndraft \u2192 revise pattern to ensure error-free production code.",
type: "object",
properties: {
type: {
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval or actual\ntask execution. Value \"complete\" indicates this is the final task\nexecution request.",
type: "string",
"enum": [
"complete"
]
},
think: {
description: "Initial error analysis and correction strategy.\n\nAnalyzes TypeScript compilation errors to understand:\n\n- Error patterns and root causes\n- Required fixes and their impact\n- Whether quick fixes or deep refactoring is needed\n- Prisma schema and API contract constraints",
type: "string"
},
draft: {
description: "First correction attempt.\n\nImplements the initial fixes identified in the think phase. For simple\nerrors (typos, missing imports), this may be the final solution. Complex\nerrors may require further refinement.",
type: "string"
},
revise: {
description: "Revision and finalization phase.\n\nReviews the draft corrections and produces the final, error-free code\nthat maintains all business requirements.",
$ref: "#/$defs/IAutoBeRealizeCorrectApplication.IReviseProps"
}
},
required: [
"type",
"think",
"draft",
"revise"
]
},
"IAutoBeRealizeCorrectApplication.IReviseProps": {
type: "object",
properties: {
review: {
description: "Correction review and validation.\n\nAnalyzes the draft corrections to ensure:\n\n- All TypeScript errors are resolved\n- Business logic remains intact\n- AutoBE coding standards are maintained\n- No new errors are introduced\n- Performance and security are preserved",
type: "string"
},
final: {
description: "Final error-free implementation.\n\nThe complete, corrected code that passes all TypeScript compilation\nchecks.\n\nReturns `null` if the draft corrections are sufficient and need no\nfurther changes.",
anyOf: [
{
type: "null"
},
{
type: "string"
}
]
}
},
required: [
"review",
"final"
]
}
}
},
description: "Process provider correction task or preliminary data requests.\n\nSystematically analyzes and corrects TypeScript compilation errors through\nthree-phase workflow (think \u2192 draft \u2192 revise). Maintains business logic\nintegrity while resolving all compilation issues.",
validate: (() => { const _io0 = input => "string" === typeof input.thinking && ("object" === typeof input.request && null !== input.request && _iu0(input.request)); const _io1 = input => "getPrismaSchemas" === input.type && (Array.isArray(input.schemaNames) && (1 <= input.schemaNames.length && input.schemaNames.every(elem => "string" === typeof elem))); const _io2 = input => "complete" === input.type && "string" === typeof input.think && "string" === typeof input.draft && ("object" === typeof input.revise && null !== input.revise && _io3(input.revise)); const _io3 = input => "string" === typeof input.review && (null === input.final || "string" === typeof input.final); const _iu0 = input => (() => {
if ("getPrismaSchemas" === input.type)
return _io1(input);
else if ("complete" === input.type)
return _io2(input);
else
return false;
})(); const _vo0 = (input, _path, _exceptionable = true) => ["string" === typeof input.thinking || _report(_exceptionable, {
path: _path + ".thinking",
expected: "string",
value: input.thinking
}), ("object" === typeof input.request && null !== input.request || _report(_exceptionable, {
path: _path + ".request",
expected: "(IAutoBePreliminaryGetPrismaSchemas | IAutoBeRealizeCorrectApplication.IComplete)",
value: input.request
})) && _vu0(input.request, _path + ".request", true && _exceptionable) || _report(_exceptionable, {
path: _path + ".request",
expected: "(IAutoBePreliminaryGetPrismaSchemas | IAutoBeRealizeCorrectApplication.IComplete)",
value: input.request
})].every(flag => flag); const _vo1 = (input, _path, _exceptionable = true) => ["getPrismaSchemas" === input.type || _report(_exceptionable, {
path: _path + ".type",
expected: "\"getPrismaSchemas\"",
value: input.type
}), (Array.isArray(input.schemaNames) || _report(_exceptionable, {
path: _path + ".schemaNames",
expected: "(Array<string> & MinItems<1>)",
value: input.schemaNames
})) && ((1 <= input.schemaNames.length || _report(_exceptionable, {
path: _path + ".schemaNames",
expected: "Array<> & MinItems<1>",
value: input.schemaNames
})) && input.schemaNames.map((elem, _index2) => "string" === typeof elem || _report(_exceptionable, {
path: _path + ".schemaNames[" + _index2 + "]",
expected: "string",
value: elem
})).every(flag => flag)) || _report(_exceptionable, {
path: _path + ".schemaNames",
expected: "(Array<string> & MinItems<1>)",
value: input.schemaNames
})].every(flag => flag); const _vo2 = (input, _path, _exceptionable = true) => ["complete" === input.type || _report(_exceptionable, {
path: _path + ".type",
expected: "\"complete\"",
value: input.type
}), "string" === typeof input.think || _report(_exceptionable, {
path: _path + ".think",
expected: "string",
value: input.think
}), "string" === typeof input.draft || _report(_exceptionable, {
path: _path + ".draft",
expected: "string",
value: input.draft
}), ("object" === typeof input.revise && null !== input.revise || _report(_exceptionable, {
path: _path + ".revise",
expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
value: input.revise
})) && _vo3(input.revise, _path + ".revise", true && _exceptionable) || _report(_exceptionable, {
path: _path + ".revise",
expected: "IAutoBeRealizeCorrectApplication.IReviseProps",
value: input.revise
})].every(flag => flag); const _vo3 = (input, _path, _exceptionable = true) => ["string" === typeof input.review || _report(_exceptionable, {
path: _path + ".review",
expected: "string",
value: input.review
}), null === input.final || "string" === typeof input.final || _report(_exceptionable, {
path: _path + ".final",
expected: "(null | string)",
value: input.final
})].every(flag => flag); const _vu0 = (input, _path, _exceptionable = true) => (() => {
if ("getPrismaSchemas" === input.type)
return _vo1(input, _path, true && _exceptionable);
else if ("complete" === input.type)
return _vo2(input, _path, true && _exceptionable);
else
return _report(_exceptionable, {
path: _path,
expected: "(IAutoBePreliminaryGetPrismaSchemas | IAutoBeRealizeCorrectApplication.IComplete)",
value: input
});
})(); const __is = input => "object" === typeof input && null !== input && _io0(input); let errors; let _report; return input => {
if (false === __is(input)) {
errors = [];
_report = __typia_transform__validateReport._validateReport(errors);
((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
path: _path + "",
expected: "IAutoBeRealizeCorrectApplication.IProps",
value: input
})) && _vo0(input, _path + "", true) || _report(true, {
path: _path + "",
expected: "IAutoBeRealizeCorrectApplication.IProps",
value: input
}))(input, "$input", true);
const success = 0 === errors.length;
return success ? {
success,
data: input
} : {
success,
errors,
data: input
};
}
return {
success: true,
data: input
};
}; })()
}
]
};
__typia_transform__llmApplicationFinalize._llmApplicationFinalize(application, Object.assign(Object.assign({}, {
validate: {
process: validate,
},
}), { equals: false }));
return application;
})(),
claude: (validate) => (() => {
const application = {
model: "claude",
options: {
reference: true,
separate: null
},
functions: [
{
name: "process",
parameters: {
description: " Request containing either preliminary data request or complete\ntask\n\n------------------------------\n\nCurrent Type: {@link IAutoBeRealizeCorrectApplication.IProps}",
type: "object",
properties: {
thinking: {
description: "Think before you act.\n\nBefore requesting preliminary data or completing your task, reflect on your\ncurrent state and explain your reasoning:\n\nFor preliminary requests (getAnalysisFiles, getPrismaSchemas, etc.):\n- What critical information is missing that you don't already have?\n- Why do you need it specifically right now?\n- Be brief - state the gap, don't list everything you have.\n\nFor completion (complete):\n- What key assets did you acquire?\n- What did you accomplish?\n- Why is it sufficient to complete?\n- Summarize - don't enumerate every single item.\n\nThis reflection helps you avoid duplicate requests and premature completion.",
type: "string"
},
request: {
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval\n(getPrismaSchemas) or final error correction (complete). When preliminary\nreturns empty array, that type is removed from the union, physically\npreventing repeated calls.",
oneOf: [
{
$ref: "#/$defs/IAutoBePreliminaryGetPrismaSchemas"
},
{
$ref: "#/$defs/IAutoBeRealizeCorrectApplication.IComplete"
}
],
discriminator: {
propertyName: "type",
mapping: {
getPrismaSchemas: "#/$defs/IAutoBePreliminaryGetPrismaSchemas",
complete: "#/$defs/IAutoBeRealizeCorrectApplication.IComplete"
}
}
}
},
required: [
"thinking",
"request"
],
additionalProperties: false,
$defs: {
IAutoBePreliminaryGetPrismaSchemas: {
description: "Request to retrieve Prisma database schema definitions for context.\n\nThis type is used in the preliminary phase to request specific Prisma table\nschemas needed for generating type-safe API operations.",
type: "object",
properties: {
type: {
description: "Type discriminator for the request.\n\nDetermines which action to perform: preliminary data retrieval or actual\ntask execution. Value \"getPrismaSchemas\" indicates this is a preliminary\ndata request for Prisma s