@agentica/core 0.33.1 → 0.34.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/constants/AgenticaSystemPrompt.js +1 -1
- package/lib/constants/AgenticaSystemPrompt.js.map +1 -1
- package/lib/functional/assertHttpController.js +1 -6
- package/lib/functional/assertHttpController.js.map +1 -1
- package/lib/functional/assertHttpLlmApplication.js +1 -6
- package/lib/functional/assertHttpLlmApplication.js.map +1 -1
- package/lib/functional/validateHttpController.js +1 -5
- package/lib/functional/validateHttpController.js.map +1 -1
- package/lib/functional/validateHttpLlmApplication.js +1 -5
- package/lib/functional/validateHttpLlmApplication.js.map +1 -1
- package/lib/index.mjs +52 -46
- package/lib/index.mjs.map +1 -1
- package/lib/orchestrate/initialize.js +50 -26
- package/lib/orchestrate/initialize.js.map +1 -1
- package/package.json +6 -6
- package/prompts/validate.md +87 -0
- package/src/constants/AgenticaSystemPrompt.ts +1 -1
|
@@ -71,7 +71,7 @@ const FUNCTION = {
|
|
|
71
71
|
additionalProperties: false,
|
|
72
72
|
$defs: {
|
|
73
73
|
IHttpLlmFunctionchatgpt: {
|
|
74
|
-
description: "LLM function calling schema from HTTP (OpenAPI) operation.\n\n`IHttpLlmFunction` is a data structure representing a function converted from\nthe {@link OpenApi.IOperation OpenAPI operation}, used for the LLM (Large\nLanguage Model) function calling. It's a typical RPC (Remote Procedure Call)\nstructure containing the function {@link name}, {@link parameters}, and\n{@link output return type}.\n\nIf you provide this `IHttpLlmFunction` data to the LLM provider like\n\"OpenAI\", the \"OpenAI\" will compose a function arguments by analyzing\nconversations with the user. With the LLM composed arguments, you can execute\nthe function through {@link LlmFetcher.execute} and get the result.\n\nFor reference, different between `IHttpLlmFunction` and its origin source\n{@link OpenApi.IOperation} is, `IHttpLlmFunction` has converted every type\nschema information from {@link OpenApi.IJsonSchema} to {@link ILlmSchemaV3} to\nescape {@link OpenApi.IJsonSchema.IReference reference types}, and downgrade\nthe version of the JSON schema to OpenAPI 3.0. It's because LLM function call\nfeature cannot understand both reference types and OpenAPI 3.1\nspecification.\n\nAdditionally, the properties' rule is:\n\n- `pathParameters`: Path parameters of {@link OpenApi.IOperation.parameters}\n- `query`: Query parameter of {@link IHttpMigrateRoute.query}\n- `body`: Body parameter of {@link IHttpMigrateRoute.body}\n\n```typescript\n{\n ...pathParameters,\n query,\n body,\n}\n
|
|
74
|
+
description: "LLM function calling schema from HTTP (OpenAPI) operation.\n\n`IHttpLlmFunction` is a data structure representing a function converted from\nthe {@link OpenApi.IOperation OpenAPI operation}, used for the LLM (Large\nLanguage Model) function calling. It's a typical RPC (Remote Procedure Call)\nstructure containing the function {@link name}, {@link parameters}, and\n{@link output return type}.\n\nIf you provide this `IHttpLlmFunction` data to the LLM provider like\n\"OpenAI\", the \"OpenAI\" will compose a function arguments by analyzing\nconversations with the user. With the LLM composed arguments, you can execute\nthe function through {@link LlmFetcher.execute} and get the result.\n\nFor reference, different between `IHttpLlmFunction` and its origin source\n{@link OpenApi.IOperation} is, `IHttpLlmFunction` has converted every type\nschema information from {@link OpenApi.IJsonSchema} to {@link ILlmSchemaV3} to\nescape {@link OpenApi.IJsonSchema.IReference reference types}, and downgrade\nthe version of the JSON schema to OpenAPI 3.0. It's because LLM function call\nfeature cannot understand both reference types and OpenAPI 3.1\nspecification.\n\nAdditionally, the properties' rule is:\n\n- `pathParameters`: Path parameters of {@link OpenApi.IOperation.parameters}\n- `query`: Query parameter of {@link IHttpMigrateRoute.query}\n- `body`: Body parameter of {@link IHttpMigrateRoute.body}\n\n```typescript\n{\n ...pathParameters,\n query,\n body,\n}\n```",
|
|
75
75
|
type: "object",
|
|
76
76
|
properties: {
|
|
77
77
|
method: {
|
|
@@ -94,17 +94,16 @@ const FUNCTION = {
|
|
|
94
94
|
type: "string"
|
|
95
95
|
},
|
|
96
96
|
parameters: {
|
|
97
|
+
description: "List of parameter types.\n\nIf you've configured {@link IHttpLlmApplication.IOptions.keyword} as `true`,\nnumber of {@link IHttpLlmFunction.parameters} are always 1 and the first\nparameter's type is always {@link ILlmSchemaV3.IObject}. The properties'\nrule is:\n\n- `pathParameters`: Path parameters of {@link IHttpMigrateRoute.parameters}\n- `query`: Query parameter of {@link IHttpMigrateRoute.query}\n- `body`: Body parameter of {@link IHttpMigrateRoute.body}\n\n```typescript\n{\n ...pathParameters,\n query,\n body,\n}\n```\n\nOtherwise, the parameters would be multiple, and the sequence of the\nparameters are following below rules:\n\n```typescript\n[\n ...pathParameters,\n ...(query ? [query] : []),\n ...(body ? [body] : []),\n];\n```",
|
|
97
98
|
$ref: "#/$defs/IChatGptSchema.IParameters"
|
|
98
99
|
},
|
|
99
100
|
separated: {
|
|
101
|
+
description: "Collection of separated parameters.\n\nFilled only when {@link IHttpLlmApplication.IOptions.separate} is\nconfigured.",
|
|
100
102
|
$ref: "#/$defs/IHttpLlmFunction.ISeparatedchatgpt"
|
|
101
103
|
},
|
|
102
104
|
output: {
|
|
103
105
|
description: "Expected return type.\n\nIf the target operation returns nothing (`void`), the `output` would be\n`undefined`.",
|
|
104
106
|
anyOf: [
|
|
105
|
-
{
|
|
106
|
-
$ref: "#/$defs/IChatGptSchema.IString"
|
|
107
|
-
},
|
|
108
107
|
{
|
|
109
108
|
$ref: "#/$defs/IChatGptSchema.INumber"
|
|
110
109
|
},
|
|
@@ -114,6 +113,9 @@ const FUNCTION = {
|
|
|
114
113
|
{
|
|
115
114
|
$ref: "#/$defs/IChatGptSchema.IBoolean"
|
|
116
115
|
},
|
|
116
|
+
{
|
|
117
|
+
$ref: "#/$defs/IChatGptSchema.IString"
|
|
118
|
+
},
|
|
117
119
|
{
|
|
118
120
|
$ref: "#/$defs/IChatGptSchema.IArray"
|
|
119
121
|
},
|
|
@@ -158,10 +160,11 @@ const FUNCTION = {
|
|
|
158
160
|
]
|
|
159
161
|
},
|
|
160
162
|
"IChatGptSchema.IParameters": {
|
|
161
|
-
description: "Type for function parameters.\n\n`IChatGptSchema.IParameters` defines a function's parameters as
|
|
163
|
+
description: "Type for function parameters.\n\n`IChatGptSchema.IParameters` defines a function's parameters as a keyword\nobject type, where each property represents a named parameter.\n\nIt can also be used for structured output metadata to define the expected\nformat of ChatGPT responses.",
|
|
162
164
|
type: "object",
|
|
163
165
|
properties: {
|
|
164
166
|
$defs: {
|
|
167
|
+
description: "Collection of the named types.",
|
|
165
168
|
$ref: "#/$defs/RecordstringIChatGptSchema"
|
|
166
169
|
},
|
|
167
170
|
additionalProperties: {
|
|
@@ -179,6 +182,7 @@ const FUNCTION = {
|
|
|
179
182
|
]
|
|
180
183
|
},
|
|
181
184
|
properties: {
|
|
185
|
+
description: "Properties of the object.\n\nThe `properties` means a list of key-value pairs of the object's regular\nproperties. The key is the name of the regular property, and the value is\nthe type schema info.",
|
|
182
186
|
$ref: "#/$defs/RecordstringIChatGptSchema"
|
|
183
187
|
},
|
|
184
188
|
required: {
|
|
@@ -204,6 +208,7 @@ const FUNCTION = {
|
|
|
204
208
|
description: "Example value."
|
|
205
209
|
},
|
|
206
210
|
examples: {
|
|
211
|
+
description: "List of example values as key-value pairs.",
|
|
207
212
|
$ref: "#/$defs/Recordstringany"
|
|
208
213
|
}
|
|
209
214
|
},
|
|
@@ -225,7 +230,7 @@ const FUNCTION = {
|
|
|
225
230
|
}
|
|
226
231
|
},
|
|
227
232
|
IChatGptSchema: {
|
|
228
|
-
description: "Type schema info
|
|
233
|
+
description: "Type schema info for OpenAI function calling.\n\n`IChatGptSchema` is a type schema info for OpenAI function calling. The type\nname \"ChatGpt\" is intentionally used to avoid confusion with \"OpenAPI\"\nspecification, even though this is designed for OpenAI models.\n\n`IChatGptSchema` basically follows the JSON schema definition of the OpenAPI\nv3.1 specification; {@link OpenApiV3_1.IJsonSchema}. However, it deviates from\nthe standard JSON schema specification and omits many features when used in\n{@link IChatGptSchema.IConfig.strict} mode for OpenAI function calling.\n\n`IChatGptSchema` supports all JSON schema features through workaround\nexpressions using JSDoc tags in the `description` property, so using\n`IChatGptSchema` does not degrade function calling performance even in strict\nmode.\n\nHere is the list of how `IChatGptSchema` is different with the OpenAPI v3.1\nJSON schema:\n\n- Decompose mixed type: {@link OpenApiV3_1.IJsonSchema.IMixed}\n- Resolve nullable property:\n {@link OpenApiV3_1.IJsonSchema.__ISignificant.nullable}\n- Tuple type is banned: {@link OpenApiV3_1.IJsonSchema.ITuple.prefixItems}\n- Constant type is banned: {@link OpenApiV3_1.IJsonSchema.IConstant}\n- Merge {@link OpenApiV3_1.IJsonSchema.IOneOf} to {@link IChatGptSchema.IAnyOf}\n- Merge {@link OpenApiV3_1.IJsonSchema.IAllOf} to {@link IChatGptSchema.IObject}\n- Merge {@link OpenApiV3_1.IJsonSchema.IRecursiveReference} to\n {@link IChatGptSchema.IReference}\n- When {@link IChatGptSchema.IConfig.strict} mode:\n\n - Every object properties must be required\n - Do not allow {@link IChatGptSchema.IObject.additionalProperties}\n\nCompared to {@link OpenApi.IJsonSchema}, the emended JSON schema\nspecification:\n\n- {@link IChatGptSchema.IAnyOf} instead of {@link OpenApi.IJsonSchema.IOneOf}\n- {@link IChatGptSchema.IParameters.$defs} instead of\n {@link OpenApi.IComponents.schemas}\n- {@link IChatGptSchema.IString.enum} instead of\n {@link OpenApi.IJsonSchema.IConstant}\n- {@link IChatGptSchema.additionalProperties} is fixed to `false` in strict mode\n- {@link IChatGptSchema.properties} and {@link IChatGptSchema.required} are\n always defined\n- No tuple type {@link OpenApi.IJsonSchema.ITuple} support\n- When {@link IChatGptSchema.IConfig.strict} mode:\n\n - Every object properties must be required\n - Do not allow {@link IChatGptSchema.IObject.additionalProperties}\n\nFor reference, if you compose the `IChatGptSchema` type with the\n{@link IChatGptSchema.IConfig.reference} `false` option (default is `false`),\nonly recursively named types are archived into the\n{@link IChatGptSchema.IParameters.$defs}, and others are escaped from the\n{@link IChatGptSchema.IReference} type.\n\nAlso, OpenAI has banned the following constraint properties. Instead,\n`IChatGptSchema` fills the {@link IChatGptSchema.description} property with\nworkaround expressions using JSDoc tags like `\"@format uuid\"` to convey these\nconstraints:\n\n- {@link OpenApi.IJsonSchema.INumber.minimum}\n- {@link OpenApi.IJsonSchema.INumber.maximum}\n- {@link OpenApi.IJsonSchema.INumber.multipleOf}\n- {@link OpenApi.IJsonSchema.IString.minLength}\n- {@link OpenApi.IJsonSchema.IString.maxLength}\n- {@link OpenApi.IJsonSchema.IString.format}\n- {@link OpenApi.IJsonSchema.IString.pattern}\n- {@link OpenApi.IJsonSchema.IString.contentMediaType}\n- {@link OpenApi.IJsonSchema.IString.default}\n- {@link OpenApi.IJsonSchema.IArray.minItems}\n- {@link OpenApi.IJsonSchema.IArray.maxItems}\n- {@link OpenApi.IJsonSchema.IArray.unique}\n\nAdditionally, OpenAI cannot define the {@link IChatGptSchema.description}\nproperty for the {@link IChatGptSchema.IReference} type, and does not\nunderstand encapsulation of the {@link IChatGptSchema.IAnyOf} type. Therefore,\nthe {@link IChatGptSchema.description} is written to the parent object type,\nnot the reference type.\n\n```json\n{\n \"type\": \"object\",\n \"description\": \"### Description of {@link something} property.\\n\\n> Hello?\",\n \"properties\": {\n \"something\": {\n \"$ref\": \"#/$defs/SomeObject\"\n }\n }\n}\n```",
|
|
229
234
|
anyOf: [
|
|
230
235
|
{
|
|
231
236
|
$ref: "#/$defs/IChatGptSchema.IBoolean"
|
|
@@ -260,7 +265,7 @@ const FUNCTION = {
|
|
|
260
265
|
]
|
|
261
266
|
},
|
|
262
267
|
"IChatGptSchema.IBoolean": {
|
|
263
|
-
description: "Boolean type info
|
|
268
|
+
description: "Boolean type info.",
|
|
264
269
|
type: "object",
|
|
265
270
|
properties: {
|
|
266
271
|
"enum": {
|
|
@@ -293,6 +298,7 @@ const FUNCTION = {
|
|
|
293
298
|
description: "Example value."
|
|
294
299
|
},
|
|
295
300
|
examples: {
|
|
301
|
+
description: "List of example values as key-value pairs.",
|
|
296
302
|
$ref: "#/$defs/Recordstringany"
|
|
297
303
|
}
|
|
298
304
|
},
|
|
@@ -308,7 +314,7 @@ const FUNCTION = {
|
|
|
308
314
|
additionalProperties: {}
|
|
309
315
|
},
|
|
310
316
|
"IChatGptSchema.IInteger": {
|
|
311
|
-
description: "Integer type info
|
|
317
|
+
description: "Integer type info.",
|
|
312
318
|
type: "object",
|
|
313
319
|
properties: {
|
|
314
320
|
"enum": {
|
|
@@ -341,6 +347,7 @@ const FUNCTION = {
|
|
|
341
347
|
description: "Example value."
|
|
342
348
|
},
|
|
343
349
|
examples: {
|
|
350
|
+
description: "List of example values as key-value pairs.",
|
|
344
351
|
$ref: "#/$defs/Recordstringany"
|
|
345
352
|
}
|
|
346
353
|
},
|
|
@@ -349,7 +356,7 @@ const FUNCTION = {
|
|
|
349
356
|
]
|
|
350
357
|
},
|
|
351
358
|
"IChatGptSchema.INumber": {
|
|
352
|
-
description: "Number (double) type info
|
|
359
|
+
description: "Number (double) type info.",
|
|
353
360
|
type: "object",
|
|
354
361
|
properties: {
|
|
355
362
|
"enum": {
|
|
@@ -382,6 +389,7 @@ const FUNCTION = {
|
|
|
382
389
|
description: "Example value."
|
|
383
390
|
},
|
|
384
391
|
examples: {
|
|
392
|
+
description: "List of example values as key-value pairs.",
|
|
385
393
|
$ref: "#/$defs/Recordstringany"
|
|
386
394
|
}
|
|
387
395
|
},
|
|
@@ -390,7 +398,7 @@ const FUNCTION = {
|
|
|
390
398
|
]
|
|
391
399
|
},
|
|
392
400
|
"IChatGptSchema.IString": {
|
|
393
|
-
description: "String type info
|
|
401
|
+
description: "String type info.",
|
|
394
402
|
type: "object",
|
|
395
403
|
properties: {
|
|
396
404
|
"enum": {
|
|
@@ -400,6 +408,10 @@ const FUNCTION = {
|
|
|
400
408
|
type: "string"
|
|
401
409
|
}
|
|
402
410
|
},
|
|
411
|
+
"default": {
|
|
412
|
+
description: "Default value.",
|
|
413
|
+
type: "string"
|
|
414
|
+
},
|
|
403
415
|
type: {
|
|
404
416
|
description: "Discriminator value of the type.",
|
|
405
417
|
type: "string",
|
|
@@ -423,6 +435,7 @@ const FUNCTION = {
|
|
|
423
435
|
description: "Example value."
|
|
424
436
|
},
|
|
425
437
|
examples: {
|
|
438
|
+
description: "List of example values as key-value pairs.",
|
|
426
439
|
$ref: "#/$defs/Recordstringany"
|
|
427
440
|
}
|
|
428
441
|
},
|
|
@@ -431,10 +444,11 @@ const FUNCTION = {
|
|
|
431
444
|
]
|
|
432
445
|
},
|
|
433
446
|
"IChatGptSchema.IArray": {
|
|
434
|
-
description: "Array type info
|
|
447
|
+
description: "Array type info.",
|
|
435
448
|
type: "object",
|
|
436
449
|
properties: {
|
|
437
450
|
items: {
|
|
451
|
+
description: "Items type info.\n\nThe `items` means the type of the array elements. In other words, it is\nthe type schema info of the `T` in the TypeScript array type `Array<T>`.",
|
|
438
452
|
$ref: "#/$defs/IChatGptSchema"
|
|
439
453
|
},
|
|
440
454
|
type: {
|
|
@@ -460,6 +474,7 @@ const FUNCTION = {
|
|
|
460
474
|
description: "Example value."
|
|
461
475
|
},
|
|
462
476
|
examples: {
|
|
477
|
+
description: "List of example values as key-value pairs.",
|
|
463
478
|
$ref: "#/$defs/Recordstringany"
|
|
464
479
|
}
|
|
465
480
|
},
|
|
@@ -469,21 +484,19 @@ const FUNCTION = {
|
|
|
469
484
|
]
|
|
470
485
|
},
|
|
471
486
|
"IChatGptSchema.IObject": {
|
|
472
|
-
description: "Object type info
|
|
487
|
+
description: "Object type info.",
|
|
473
488
|
type: "object",
|
|
474
489
|
properties: {
|
|
475
490
|
properties: {
|
|
491
|
+
description: "Properties of the object.\n\nThe `properties` means a list of key-value pairs of the object's regular\nproperties. The key is the name of the regular property, and the value is\nthe type schema info.",
|
|
476
492
|
$ref: "#/$defs/RecordstringIChatGptSchema"
|
|
477
493
|
},
|
|
478
494
|
additionalProperties: {
|
|
479
|
-
description: "Additional properties information.\n\nThe `additionalProperties` defines the type schema for additional\nproperties that are not listed in the {@link properties}.\n\nNote: If you've configured {@link IChatGptSchema.IConfig.strict} as\n`true`, ChatGPT function calling does not support dynamic key typed\nproperties, so `additionalProperties` is always `false`.",
|
|
495
|
+
description: "Additional properties information.\n\nThe `additionalProperties` defines the type schema for additional\nproperties that are not listed in the {@link properties}.\n\nIf the value is `true`, it means that the additional properties are not\nrestricted. They can be any type. Otherwise, if the value is\n{@link IChatGptSchema} type, it means that the additional properties must\nfollow the type schema info.\n\n- `true`: `Record<string, any>`\n- `IChatGptSchema`: `Record<string, T>`\n\nNote: If you've configured {@link IChatGptSchema.IConfig.strict} as\n`true`, ChatGPT function calling does not support dynamic key typed\nproperties, so `additionalProperties` is always `false`.",
|
|
480
496
|
anyOf: [
|
|
481
497
|
{
|
|
482
498
|
type: "boolean"
|
|
483
499
|
},
|
|
484
|
-
{
|
|
485
|
-
$ref: "#/$defs/IChatGptSchema.IString"
|
|
486
|
-
},
|
|
487
500
|
{
|
|
488
501
|
$ref: "#/$defs/IChatGptSchema.INumber"
|
|
489
502
|
},
|
|
@@ -493,6 +506,9 @@ const FUNCTION = {
|
|
|
493
506
|
{
|
|
494
507
|
$ref: "#/$defs/IChatGptSchema.IBoolean"
|
|
495
508
|
},
|
|
509
|
+
{
|
|
510
|
+
$ref: "#/$defs/IChatGptSchema.IString"
|
|
511
|
+
},
|
|
496
512
|
{
|
|
497
513
|
$ref: "#/$defs/IChatGptSchema.IArray"
|
|
498
514
|
},
|
|
@@ -543,6 +559,7 @@ const FUNCTION = {
|
|
|
543
559
|
description: "Example value."
|
|
544
560
|
},
|
|
545
561
|
examples: {
|
|
562
|
+
description: "List of example values as key-value pairs.",
|
|
546
563
|
$ref: "#/$defs/Recordstringany"
|
|
547
564
|
}
|
|
548
565
|
},
|
|
@@ -553,11 +570,11 @@ const FUNCTION = {
|
|
|
553
570
|
]
|
|
554
571
|
},
|
|
555
572
|
"IChatGptSchema.IReference": {
|
|
556
|
-
description: "Reference type directing to named schema
|
|
573
|
+
description: "Reference type directing to named schema.",
|
|
557
574
|
type: "object",
|
|
558
575
|
properties: {
|
|
559
576
|
$ref: {
|
|
560
|
-
description: "Reference to the named schema.\n\nThe `$ref` is a reference to a named schema. The format follows the\
|
|
577
|
+
description: "Reference to the named schema.\n\nThe `$ref` is a reference to a named schema. The format follows the JSON\nPointer specification. In OpenAPI, the `$ref` starts with `#/$defs/`\nwhich indicates the type is stored in the\n{@link IChatGptSchema.IParameters.$defs} object.\n\n- `#/$defs/SomeObject`\n- `#/$defs/AnotherObject`",
|
|
561
578
|
type: "string"
|
|
562
579
|
},
|
|
563
580
|
title: {
|
|
@@ -576,6 +593,7 @@ const FUNCTION = {
|
|
|
576
593
|
description: "Example value."
|
|
577
594
|
},
|
|
578
595
|
examples: {
|
|
596
|
+
description: "List of example values as key-value pairs.",
|
|
579
597
|
$ref: "#/$defs/Recordstringany"
|
|
580
598
|
}
|
|
581
599
|
},
|
|
@@ -584,7 +602,7 @@ const FUNCTION = {
|
|
|
584
602
|
]
|
|
585
603
|
},
|
|
586
604
|
"IChatGptSchema.IAnyOf": {
|
|
587
|
-
description: "Union type.\n\n`IAnyOf` represents a union type in TypeScript (`A | B | C`).\n\nFor reference, even if your Swagger (or OpenAPI) document defines
|
|
605
|
+
description: "Union type.\n\n`IAnyOf` represents a union type in TypeScript (`A | B | C`).\n\nFor reference, even if your Swagger (or OpenAPI) document defines `anyOf`\ninstead of `oneOf`, {@link IChatGptSchema} forcibly converts it to `anyOf`\ntype.",
|
|
588
606
|
type: "object",
|
|
589
607
|
properties: {
|
|
590
608
|
anyOf: {
|
|
@@ -592,9 +610,6 @@ const FUNCTION = {
|
|
|
592
610
|
type: "array",
|
|
593
611
|
items: {
|
|
594
612
|
anyOf: [
|
|
595
|
-
{
|
|
596
|
-
$ref: "#/$defs/IChatGptSchema.IString"
|
|
597
|
-
},
|
|
598
613
|
{
|
|
599
614
|
$ref: "#/$defs/IChatGptSchema.INumber"
|
|
600
615
|
},
|
|
@@ -604,6 +619,9 @@ const FUNCTION = {
|
|
|
604
619
|
{
|
|
605
620
|
$ref: "#/$defs/IChatGptSchema.IBoolean"
|
|
606
621
|
},
|
|
622
|
+
{
|
|
623
|
+
$ref: "#/$defs/IChatGptSchema.IString"
|
|
624
|
+
},
|
|
607
625
|
{
|
|
608
626
|
$ref: "#/$defs/IChatGptSchema.IArray"
|
|
609
627
|
},
|
|
@@ -623,6 +641,7 @@ const FUNCTION = {
|
|
|
623
641
|
}
|
|
624
642
|
},
|
|
625
643
|
"x-discriminator": {
|
|
644
|
+
description: "Discriminator info of the union type.",
|
|
626
645
|
$ref: "#/$defs/IChatGptSchema.IAnyOf.IDiscriminator"
|
|
627
646
|
},
|
|
628
647
|
title: {
|
|
@@ -641,6 +660,7 @@ const FUNCTION = {
|
|
|
641
660
|
description: "Example value."
|
|
642
661
|
},
|
|
643
662
|
examples: {
|
|
663
|
+
description: "List of example values as key-value pairs.",
|
|
644
664
|
$ref: "#/$defs/Recordstringany"
|
|
645
665
|
}
|
|
646
666
|
},
|
|
@@ -649,7 +669,7 @@ const FUNCTION = {
|
|
|
649
669
|
]
|
|
650
670
|
},
|
|
651
671
|
"IChatGptSchema.IUnknown": {
|
|
652
|
-
description: "Unknown, the `any` type
|
|
672
|
+
description: "Unknown, the `any` type.",
|
|
653
673
|
type: "object",
|
|
654
674
|
properties: {
|
|
655
675
|
title: {
|
|
@@ -668,13 +688,14 @@ const FUNCTION = {
|
|
|
668
688
|
description: "Example value."
|
|
669
689
|
},
|
|
670
690
|
examples: {
|
|
691
|
+
description: "List of example values as key-value pairs.",
|
|
671
692
|
$ref: "#/$defs/Recordstringany"
|
|
672
693
|
}
|
|
673
694
|
},
|
|
674
695
|
required: []
|
|
675
696
|
},
|
|
676
697
|
"IChatGptSchema.INull": {
|
|
677
|
-
description: "Null type
|
|
698
|
+
description: "Null type.",
|
|
678
699
|
type: "object",
|
|
679
700
|
properties: {
|
|
680
701
|
type: {
|
|
@@ -700,6 +721,7 @@ const FUNCTION = {
|
|
|
700
721
|
description: "Example value."
|
|
701
722
|
},
|
|
702
723
|
examples: {
|
|
724
|
+
description: "List of example values as key-value pairs.",
|
|
703
725
|
$ref: "#/$defs/Recordstringany"
|
|
704
726
|
}
|
|
705
727
|
},
|
|
@@ -708,7 +730,7 @@ const FUNCTION = {
|
|
|
708
730
|
]
|
|
709
731
|
},
|
|
710
732
|
"IChatGptSchema.IAnyOf.IDiscriminator": {
|
|
711
|
-
description: "Discriminator info of the union type
|
|
733
|
+
description: "Discriminator info of the union type.",
|
|
712
734
|
type: "object",
|
|
713
735
|
properties: {
|
|
714
736
|
propertyName: {
|
|
@@ -716,6 +738,7 @@ const FUNCTION = {
|
|
|
716
738
|
type: "string"
|
|
717
739
|
},
|
|
718
740
|
mapping: {
|
|
741
|
+
description: "Mapping of discriminator values to schema names.\n\nThis property is valid only for {@link IReference} typed\n{@link IAnyOf.anyOf} elements. Therefore, the `key` of `mapping` is the\ndiscriminator value, and the `value` of `mapping` is the schema name\nlike `#/components/schemas/SomeObject`.",
|
|
719
742
|
$ref: "#/$defs/Recordstringstring"
|
|
720
743
|
}
|
|
721
744
|
},
|
|
@@ -733,10 +756,11 @@ const FUNCTION = {
|
|
|
733
756
|
}
|
|
734
757
|
},
|
|
735
758
|
"IHttpLlmFunction.ISeparatedchatgpt": {
|
|
736
|
-
description: "Collection of separated parameters
|
|
759
|
+
description: "Collection of separated parameters.",
|
|
737
760
|
type: "object",
|
|
738
761
|
properties: {
|
|
739
762
|
llm: {
|
|
763
|
+
description: "Parameters that would be composed by the LLM.\n\nEven though no property exists in the LLM side, the `llm` property would\nhave at least empty object type.",
|
|
740
764
|
$ref: "#/$defs/IChatGptSchema.IParameters"
|
|
741
765
|
},
|
|
742
766
|
human: {
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"initialize.js","sourceRoot":"","sources":["../../src/orchestrate/initialize.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA,gCAqEC;;AAtFD,kDAA0B;AAM1B,8EAA2E;AAC3E,4EAAyE;AACzE,8CAAgE;AAChE,oDAA+E;AAC/E,4FAAsF;AAEtF,MAAM,QAAQ,GAA4B
|
|
1
|
+
{"version":3,"file":"initialize.js","sourceRoot":"","sources":["../../src/orchestrate/initialize.ts"],"names":[],"mappings":"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"}
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@agentica/core",
|
|
3
|
-
"version": "0.
|
|
3
|
+
"version": "0.34.0",
|
|
4
4
|
"description": "Agentic AI Library specialized in LLM Function Calling",
|
|
5
5
|
"author": "Wrtn Technologies",
|
|
6
6
|
"license": "MIT",
|
|
@@ -37,9 +37,9 @@
|
|
|
37
37
|
},
|
|
38
38
|
"peerDependencies": {
|
|
39
39
|
"@modelcontextprotocol/sdk": "^1.12.0",
|
|
40
|
-
"@samchon/openapi": "^
|
|
40
|
+
"@samchon/openapi": "^5.0.0",
|
|
41
41
|
"openai": "^6.7.0",
|
|
42
|
-
"typia": "^
|
|
42
|
+
"typia": "^10.0.0"
|
|
43
43
|
},
|
|
44
44
|
"peerDependenciesMeta": {
|
|
45
45
|
"@modelcontextprotocol/sdk": {
|
|
@@ -47,10 +47,10 @@
|
|
|
47
47
|
}
|
|
48
48
|
},
|
|
49
49
|
"dependencies": {
|
|
50
|
-
"@samchon/openapi": "^
|
|
50
|
+
"@samchon/openapi": "^5.0.0",
|
|
51
51
|
"es-jsonkit": "^0.1.6",
|
|
52
52
|
"tstl": "^3.0.0",
|
|
53
|
-
"typia": "^
|
|
53
|
+
"typia": "^10.0.0",
|
|
54
54
|
"uuid": "^11.0.4"
|
|
55
55
|
},
|
|
56
56
|
"devDependencies": {
|
|
@@ -69,7 +69,7 @@
|
|
|
69
69
|
"ts-patch": "^3.3.0",
|
|
70
70
|
"tstl": "^3.0.0",
|
|
71
71
|
"typedoc": "^0.27.7",
|
|
72
|
-
"typescript": "~5.9.
|
|
72
|
+
"typescript": "~5.9.3",
|
|
73
73
|
"vitest": "^3.0.9"
|
|
74
74
|
},
|
|
75
75
|
"scripts": {
|
package/prompts/validate.md
CHANGED
|
@@ -6,6 +6,93 @@ You are a specialized AI function calling corrector agent designed to analyze va
|
|
|
6
6
|
|
|
7
7
|
When an AI function call fails validation, you receive detailed error information in the form of `IValidation.IFailure` and must produce corrected function arguments that will pass validation successfully. Your role is to be the "fix-it" agent that ensures function calls achieve 100% schema compliance through **holistic analysis and aggressive correction**.
|
|
8
8
|
|
|
9
|
+
## 🚨 Fundamental Principle: Validation Results Are Absolute Truth
|
|
10
|
+
|
|
11
|
+
**CRITICAL UNDERSTANDING**: The `IValidation.IFailure` you receive is not a suggestion or guideline—it is **computed absolute truth** produced by rigorous type validation logic (typia). These validation failures represent mathematical certainty, not human opinion.
|
|
12
|
+
|
|
13
|
+
### Non-Negotiable Compliance Rules
|
|
14
|
+
|
|
15
|
+
1. **Validation failures are 100% correct by definition** - They result from precise type-checking algorithms with zero margin for interpretation
|
|
16
|
+
2. **Your judgment is irrelevant** - Even if you believe the original value "makes sense" or "should be valid," if validation reports an error, you are definitively wrong
|
|
17
|
+
3. **Zero tolerance for rationalization** - You have no authority to question, dispute, or argue against validation results
|
|
18
|
+
4. **Absolute obedience required** - Fix EVERY error exactly as specified, without inserting personal judgment or assumptions
|
|
19
|
+
|
|
20
|
+
### Why Your Intuition Cannot Override Validation
|
|
21
|
+
|
|
22
|
+
**Validation logic = Mathematical precision**
|
|
23
|
+
**Your pattern-based intuition = Unreliable**
|
|
24
|
+
|
|
25
|
+
- ❌ Your sense of "what should be valid" is irrelevant
|
|
26
|
+
- ❌ Your reasoning about "why this might be acceptable" is wrong
|
|
27
|
+
- ❌ Your thoughts like "but this makes business sense" are dangerous
|
|
28
|
+
- ✅ Validation failures are always correct
|
|
29
|
+
- ✅ Your only responsibility is complete compliance
|
|
30
|
+
|
|
31
|
+
### Forbidden Rationalization Patterns
|
|
32
|
+
|
|
33
|
+
**YOU MUST NEVER:**
|
|
34
|
+
|
|
35
|
+
- ❌ Think "but this value seems reasonable to me"
|
|
36
|
+
- ❌ Rationalize why the original value might be acceptable
|
|
37
|
+
- ❌ Suggest the validation requirements are too strict
|
|
38
|
+
- ❌ Propose alternative interpretations of constraints
|
|
39
|
+
- ❌ Insert personal judgment about what's "good enough"
|
|
40
|
+
- ❌ Partially fix or ignore seemingly minor errors
|
|
41
|
+
- ❌ Treat validation errors as optional feedback
|
|
42
|
+
|
|
43
|
+
### Required Mental Model
|
|
44
|
+
|
|
45
|
+
**When confronted with validation failures:**
|
|
46
|
+
|
|
47
|
+
```
|
|
48
|
+
IF validation reports an error
|
|
49
|
+
THEN it is an error—no exceptions, no debate
|
|
50
|
+
|
|
51
|
+
Your response must be:
|
|
52
|
+
1. Accept the error as absolute fact
|
|
53
|
+
2. Understand exactly what's required
|
|
54
|
+
3. Fix it completely
|
|
55
|
+
4. Verify compliance
|
|
56
|
+
|
|
57
|
+
Never question, never rationalize, never compromise
|
|
58
|
+
```
|
|
59
|
+
|
|
60
|
+
**Your role is exclusively:**
|
|
61
|
+
- ✅ Achieving 100% compliance with validation requirements
|
|
62
|
+
- ❌ NOT evaluating whether errors are "real"
|
|
63
|
+
- ❌ NOT judging whether requirements are "reasonable"
|
|
64
|
+
- ❌ NOT applying your own standards or preferences
|
|
65
|
+
|
|
66
|
+
### Consequences of Non-Compliance
|
|
67
|
+
|
|
68
|
+
**If you ignore, rationalize, or incompletely address validation errors:**
|
|
69
|
+
|
|
70
|
+
1. ⚠️ Corrected arguments will fail validation again
|
|
71
|
+
2. ⚠️ You waste computational resources and time
|
|
72
|
+
3. ⚠️ You frustrate users with repeated failures
|
|
73
|
+
4. ⚠️ You demonstrate fundamental unreliability
|
|
74
|
+
5. ⚠️ You fail at your core purpose
|
|
75
|
+
|
|
76
|
+
### The Only Acceptable Mindset
|
|
77
|
+
|
|
78
|
+
```markdown
|
|
79
|
+
✅ CORRECT APPROACH:
|
|
80
|
+
"Validation has identified these specific errors.
|
|
81
|
+
These errors are computed facts.
|
|
82
|
+
My sole job is to fix every single one completely.
|
|
83
|
+
I will not question, rationalize, or apply personal judgment.
|
|
84
|
+
I will achieve 100% schema compliance."
|
|
85
|
+
|
|
86
|
+
❌ UNACCEPTABLE APPROACH:
|
|
87
|
+
"This error seems minor..."
|
|
88
|
+
"The original value kind of makes sense..."
|
|
89
|
+
"Maybe the validation is too strict..."
|
|
90
|
+
"I think this should be acceptable..."
|
|
91
|
+
"Let me just fix the obvious ones..."
|
|
92
|
+
```
|
|
93
|
+
|
|
94
|
+
Validation results represent mathematical certainty. Your judgment represents pattern-matching approximation. In any conflict, validation wins—always, without exception, no discussion.
|
|
95
|
+
|
|
9
96
|
## Validation Failure Type Reference
|
|
10
97
|
|
|
11
98
|
You will receive validation failure information in this exact TypeScript interface structure:
|