@orq-ai/node 3.9.6 → 3.9.7

package/bin/mcp-server.js

@@ -34206,9 +34206,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "2.0",
-    sdkVersion: "3.9.6",
+    sdkVersion: "3.9.7",
     genVersion: "2.654.2",
-    userAgent: "speakeasy-sdk/typescript 3.9.6 2.654.2 2.0 @orq-ai/node"
+    userAgent: "speakeasy-sdk/typescript 3.9.7 2.654.2 2.0 @orq-ai/node"
   };
 });
 
@@ -35881,7 +35881,7 @@ var init_createcontact = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -35901,7 +35901,7 @@ var init_createcontact = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -35973,7 +35973,7 @@ var init_createdataset = __esm(() => {
     updated_by_id: stringType().optional(),
     metadata: lazyType(() => CreateDatasetMetadata$inboundSchema),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -35993,7 +35993,7 @@ var init_createdataset = __esm(() => {
     updatedById: stringType().optional(),
     metadata: lazyType(() => CreateDatasetMetadata$outboundSchema),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -37125,7 +37125,7 @@ var init_createdatasetitem = __esm(() => {
     created_by_id: stringType().optional(),
     updated_by_id: stringType().optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -37152,7 +37152,7 @@ var init_createdatasetitem = __esm(() => {
     createdById: stringType().optional(),
     updatedById: stringType().optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -37374,7 +37374,7 @@ var init_createdatasource = __esm(() => {
     CreateDatasourceStatus$.outboundSchema = CreateDatasourceStatus$outboundSchema;
   })(CreateDatasourceStatus$ ||= {});
   CreateDatasourceResponseBody$inboundSchema = objectType({
-    _id: stringType().default("01JZR9S4ZP9F6NPM8XS0RT7ZSZ"),
+    _id: stringType().default("01JZRA0D8GATJ97BT9QW9Y43G3"),
     display_name: stringType(),
     description: stringType().optional(),
     status: CreateDatasourceStatus$inboundSchema,
@@ -37397,7 +37397,7 @@ var init_createdatasource = __esm(() => {
     });
   });
   CreateDatasourceResponseBody$outboundSchema = objectType({
-    id: stringType().default("01JZR9S4ZP9F6NPM8XS0RT7ZSZ"),
+    id: stringType().default("01JZRA0D8GATJ97BT9QW9Y43G3"),
     displayName: stringType(),
     description: stringType().optional(),
     status: CreateDatasourceStatus$outboundSchema,
@@ -38073,8 +38073,8 @@ var init_createeval = __esm(() => {
   ResponseBodyPython$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$inboundSchema)
@@ -38091,8 +38091,8 @@ var init_createeval = __esm(() => {
   ResponseBodyPython$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$outboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$outboundSchema)
@@ -38185,8 +38185,8 @@ var init_createeval = __esm(() => {
   ResponseBodyHTTP$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$inboundSchema)
@@ -38206,8 +38206,8 @@ var init_createeval = __esm(() => {
   ResponseBodyHTTP$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$outboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$outboundSchema)
@@ -38297,8 +38297,8 @@ var init_createeval = __esm(() => {
   ResponseBodyJSON$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200Number$inboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200Boolean$inboundSchema)
@@ -38315,8 +38315,8 @@ var init_createeval = __esm(() => {
   ResponseBodyJSON$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200Number$outboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponse200Boolean$outboundSchema)
@@ -38403,8 +38403,8 @@ var init_createeval = __esm(() => {
   ResponseBodyLLM$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponseNumber$inboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponseBoolean$inboundSchema)
@@ -38422,8 +38422,8 @@ var init_createeval = __esm(() => {
   ResponseBodyLLM$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => CreateEvalGuardrailConfigEvalsResponseNumber$outboundSchema),
       lazyType(() => CreateEvalGuardrailConfigEvalsResponseBoolean$outboundSchema)
@@ -48221,7 +48221,7 @@ var init_fileget = __esm(() => {
     bytes: numberType(),
     file_name: stringType(),
     workspace_id: stringType(),
-    created: stringType().datetime({ offset: true }).default("2025-07-09T19:14:37.432Z").transform((v2) => new Date(v2))
+    created: stringType().datetime({ offset: true }).default("2025-07-09T19:18:35.432Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -48237,7 +48237,7 @@ var init_fileget = __esm(() => {
     bytes: numberType(),
     fileName: stringType(),
     workspaceId: stringType(),
-    created: dateType().default(() => new Date("2025-07-09T19:14:37.432Z")).transform((v2) => v2.toISOString())
+    created: dateType().default(() => new Date("2025-07-09T19:18:35.432Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -48308,7 +48308,7 @@ var init_filelist = __esm(() => {
     bytes: numberType(),
     file_name: stringType(),
     workspace_id: stringType(),
-    created: stringType().datetime({ offset: true }).default("2025-07-09T19:14:37.432Z").transform((v2) => new Date(v2))
+    created: stringType().datetime({ offset: true }).default("2025-07-09T19:18:35.432Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -48324,7 +48324,7 @@ var init_filelist = __esm(() => {
     bytes: numberType(),
     fileName: stringType(),
     workspaceId: stringType(),
-    created: dateType().default(() => new Date("2025-07-09T19:14:37.432Z")).transform((v2) => v2.toISOString())
+    created: dateType().default(() => new Date("2025-07-09T19:18:35.432Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -48456,7 +48456,7 @@ var init_fileupload = __esm(() => {
     bytes: numberType(),
     file_name: stringType(),
     workspace_id: stringType(),
-    created: stringType().datetime({ offset: true }).default("2025-07-09T19:14:37.432Z").transform((v2) => new Date(v2))
+    created: stringType().datetime({ offset: true }).default("2025-07-09T19:18:35.432Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -48472,7 +48472,7 @@ var init_fileupload = __esm(() => {
     bytes: numberType(),
     fileName: stringType(),
     workspaceId: stringType(),
-    created: dateType().default(() => new Date("2025-07-09T19:14:37.432Z")).transform((v2) => v2.toISOString())
+    created: dateType().default(() => new Date("2025-07-09T19:18:35.432Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -49477,8 +49477,8 @@ var init_getevals = __esm(() => {
   Typescript$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONBoolean$inboundSchema)
@@ -49495,8 +49495,8 @@ var init_getevals = __esm(() => {
   Typescript$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONNumber$outboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONBoolean$outboundSchema)
@@ -49589,8 +49589,8 @@ var init_getevals = __esm(() => {
   Ragas$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200Number$inboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200Boolean$inboundSchema)
@@ -49609,8 +49609,8 @@ var init_getevals = __esm(() => {
   Ragas$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200Number$outboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200Boolean$outboundSchema)
@@ -50161,8 +50161,8 @@ var init_getevals = __esm(() => {
   DataFunction$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponseNumber$inboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponseBoolean$inboundSchema)
@@ -50205,8 +50205,8 @@ var init_getevals = __esm(() => {
   DataFunction$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponseNumber$outboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponseBoolean$outboundSchema)
@@ -50319,8 +50319,8 @@ var init_getevals = __esm(() => {
   DataPython$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsNumber$inboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsBoolean$inboundSchema)
@@ -50337,8 +50337,8 @@ var init_getevals = __esm(() => {
   DataPython$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsNumber$outboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsBoolean$outboundSchema)
@@ -50431,8 +50431,8 @@ var init_getevals = __esm(() => {
   DataHTTP$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => GetEvalsGuardrailConfigNumber$inboundSchema),
       lazyType(() => GetEvalsGuardrailConfigBoolean$inboundSchema)
@@ -50452,8 +50452,8 @@ var init_getevals = __esm(() => {
   DataHTTP$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => GetEvalsGuardrailConfigNumber$outboundSchema),
       lazyType(() => GetEvalsGuardrailConfigBoolean$outboundSchema)
@@ -50543,8 +50543,8 @@ var init_getevals = __esm(() => {
   DataJSON$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyDataNumber$inboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyDataBoolean$inboundSchema)
@@ -50561,8 +50561,8 @@ var init_getevals = __esm(() => {
   DataJSON$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyDataNumber$outboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyDataBoolean$outboundSchema)
@@ -50649,8 +50649,8 @@ var init_getevals = __esm(() => {
   DataLLM$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$inboundSchema)
@@ -50668,8 +50668,8 @@ var init_getevals = __esm(() => {
   DataLLM$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$outboundSchema),
       lazyType(() => GetEvalsGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$outboundSchema)
@@ -53066,7 +53066,7 @@ var init_listcontacts = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2)),
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2)),
     metrics: lazyType(() => Metrics$inboundSchema)
   }).transform((v2) => {
     return remap(v2, {
@@ -53085,7 +53085,7 @@ var init_listcontacts = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString()),
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString()),
     metrics: lazyType(() => Metrics$outboundSchema)
   }).transform((v2) => {
     return remap(v2, {
@@ -53700,7 +53700,7 @@ var init_listdatasetdatapoints = __esm(() => {
     created_by_id: stringType().optional(),
     updated_by_id: stringType().optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -53727,7 +53727,7 @@ var init_listdatasetdatapoints = __esm(() => {
     createdById: stringType().optional(),
     updatedById: stringType().optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -53835,7 +53835,7 @@ var init_listdatasets = __esm(() => {
     updated_by_id: stringType().optional(),
     metadata: lazyType(() => ListDatasetsMetadata$inboundSchema),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -53855,7 +53855,7 @@ var init_listdatasets = __esm(() => {
     updatedById: stringType().optional(),
     metadata: lazyType(() => ListDatasetsMetadata$outboundSchema),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -53960,7 +53960,7 @@ var init_listdatasources = __esm(() => {
     ListDatasourcesStatus$.outboundSchema = ListDatasourcesStatus$outboundSchema;
   })(ListDatasourcesStatus$ ||= {});
   ListDatasourcesData$inboundSchema = objectType({
-    _id: stringType().default("01JZR9S4ZNW6VGH3XM6S10SVQ1"),
+    _id: stringType().default("01JZRA0D8EBCZWP0N3VDXH68B5"),
     display_name: stringType(),
     description: stringType().optional(),
     status: ListDatasourcesStatus$inboundSchema,
@@ -53983,7 +53983,7 @@ var init_listdatasources = __esm(() => {
     });
   });
   ListDatasourcesData$outboundSchema = objectType({
-    id: stringType().default("01JZR9S4ZNW6VGH3XM6S10SVQ1"),
+    id: stringType().default("01JZRA0D8EBCZWP0N3VDXH68B5"),
     displayName: stringType(),
     description: stringType().optional(),
     status: ListDatasourcesStatus$outboundSchema,
@@ -54960,6 +54960,467 @@ var init_listpromptversions = __esm(() => {
   })(ListPromptVersionsResponseBody$ ||= {});
 });
 
+// src/models/operations/parse.ts
+var ParseChunkingRequestChunkingRequestRequestBodyReturnType, AgenticChunker, ParseChunkingRequestChunkingRequestReturnType, SDPMChunker, ParseThreshold2, ChunkingRequestMode, ParseChunkingRequestChunkingReturnType, SemanticChunker, Threshold2, Mode, ParseChunkingRequestReturnType, RecursiveChunker, ChunkingRequestReturnType, SentenceChunker, ReturnTypeT, TokenChunker, ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema, ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema, ParseChunkingRequestChunkingRequestRequestBodyReturnType$, AgenticChunker$inboundSchema, AgenticChunker$outboundSchema, AgenticChunker$, AgenticChunkerStrategy$inboundSchema, AgenticChunkerStrategy$outboundSchema, AgenticChunkerStrategy$, ParseChunkingRequestChunkingRequestReturnType$inboundSchema, ParseChunkingRequestChunkingRequestReturnType$outboundSchema, ParseChunkingRequestChunkingRequestReturnType$, SDPMChunker$inboundSchema, SDPMChunker$outboundSchema, SDPMChunker$, ParseThreshold2$inboundSchema, ParseThreshold2$outboundSchema, ParseThreshold2$, ChunkingRequestThreshold$inboundSchema, ChunkingRequestThreshold$outboundSchema, ChunkingRequestThreshold$, ChunkingRequestMode$inboundSchema, ChunkingRequestMode$outboundSchema, ChunkingRequestMode$, SDPMChunkerStrategy$inboundSchema, SDPMChunkerStrategy$outboundSchema, SDPMChunkerStrategy$, ParseChunkingRequestChunkingReturnType$inboundSchema, ParseChunkingRequestChunkingReturnType$outboundSchema, ParseChunkingRequestChunkingReturnType$, SemanticChunker$inboundSchema, SemanticChunker$outboundSchema, SemanticChunker$, Threshold2$inboundSchema, Threshold2$outboundSchema, Threshold2$, Threshold$inboundSchema, Threshold$outboundSchema, Threshold$, Mode$inboundSchema, Mode$outboundSchema, Mode$, SemanticChunkerStrategy$inboundSchema, SemanticChunkerStrategy$outboundSchema, SemanticChunkerStrategy$, ParseChunkingRequestReturnType$inboundSchema, ParseChunkingRequestReturnType$outboundSchema, ParseChunkingRequestReturnType$, RecursiveChunker$inboundSchema, RecursiveChunker$outboundSchema, RecursiveChunker$, RecursiveChunkerStrategy$inboundSchema, RecursiveChunkerStrategy$outboundSchema, RecursiveChunkerStrategy$, ChunkingRequestReturnType$inboundSchema, ChunkingRequestReturnType$outboundSchema, ChunkingRequestReturnType$, SentenceChunker$inboundSchema, SentenceChunker$outboundSchema, SentenceChunker$, SentenceChunkerStrategy$inboundSchema, SentenceChunkerStrategy$outboundSchema, SentenceChunkerStrategy$, ReturnTypeT$inboundSchema, ReturnTypeT$outboundSchema, ReturnTypeT$, TokenChunker$inboundSchema, TokenChunker$outboundSchema, TokenChunker$, TokenChunkerStrategy$inboundSchema, TokenChunkerStrategy$outboundSchema, TokenChunkerStrategy$, ParseChunkingRequest$inboundSchema, ParseChunkingRequest$outboundSchema, ParseChunkingRequest$, ParseMetadata$inboundSchema, ParseMetadata$outboundSchema, ParseMetadata$, Chunks$inboundSchema, Chunks$outboundSchema, Chunks$, ParseResponseBody$inboundSchema, ParseResponseBody$outboundSchema, ParseResponseBody$;
+var init_parse = __esm(() => {
+  init_esm();
+  init_primitives();
+  ParseChunkingRequestChunkingRequestRequestBodyReturnType = {
+    Chunks: "chunks",
+    Texts: "texts"
+  };
+  AgenticChunker = {
+    Agentic: "agentic"
+  };
+  ParseChunkingRequestChunkingRequestReturnType = {
+    Chunks: "chunks",
+    Texts: "texts"
+  };
+  SDPMChunker = {
+    Sdpm: "sdpm"
+  };
+  ParseThreshold2 = {
+    Auto: "auto"
+  };
+  ChunkingRequestMode = {
+    Window: "window",
+    Sentence: "sentence"
+  };
+  ParseChunkingRequestChunkingReturnType = {
+    Chunks: "chunks",
+    Texts: "texts"
+  };
+  SemanticChunker = {
+    Semantic: "semantic"
+  };
+  Threshold2 = {
+    Auto: "auto"
+  };
+  Mode = {
+    Window: "window",
+    Sentence: "sentence"
+  };
+  ParseChunkingRequestReturnType = {
+    Chunks: "chunks",
+    Texts: "texts"
+  };
+  RecursiveChunker = {
+    Recursive: "recursive"
+  };
+  ChunkingRequestReturnType = {
+    Chunks: "chunks",
+    Texts: "texts"
+  };
+  SentenceChunker = {
+    Sentence: "sentence"
+  };
+  ReturnTypeT = {
+    Chunks: "chunks",
+    Texts: "texts"
+  };
+  TokenChunker = {
+    Token: "token"
+  };
+  ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema = nativeEnumType(ParseChunkingRequestChunkingRequestRequestBodyReturnType);
+  ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema = ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema;
+  ((ParseChunkingRequestChunkingRequestRequestBodyReturnType$) => {
+    ParseChunkingRequestChunkingRequestRequestBodyReturnType$.inboundSchema = ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema;
+    ParseChunkingRequestChunkingRequestRequestBodyReturnType$.outboundSchema = ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema;
+  })(ParseChunkingRequestChunkingRequestRequestBodyReturnType$ ||= {});
+  AgenticChunker$inboundSchema = nativeEnumType(AgenticChunker);
+  AgenticChunker$outboundSchema = AgenticChunker$inboundSchema;
+  ((AgenticChunker$) => {
+    AgenticChunker$.inboundSchema = AgenticChunker$inboundSchema;
+    AgenticChunker$.outboundSchema = AgenticChunker$outboundSchema;
+  })(AgenticChunker$ ||= {});
+  AgenticChunkerStrategy$inboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    return_type: ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema.default("chunks"),
+    strategy: AgenticChunker$inboundSchema,
+    model: stringType(),
+    chunk_size: numberType().int().default(1024),
+    candidate_size: numberType().int().default(128),
+    min_characters_per_chunk: numberType().int().default(24)
+  }).transform((v2) => {
+    return remap(v2, {
+      return_type: "returnType",
+      chunk_size: "chunkSize",
+      candidate_size: "candidateSize",
+      min_characters_per_chunk: "minCharactersPerChunk"
+    });
+  });
+  AgenticChunkerStrategy$outboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    returnType: ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema.default("chunks"),
+    strategy: AgenticChunker$outboundSchema,
+    model: stringType(),
+    chunkSize: numberType().int().default(1024),
+    candidateSize: numberType().int().default(128),
+    minCharactersPerChunk: numberType().int().default(24)
+  }).transform((v2) => {
+    return remap(v2, {
+      returnType: "return_type",
+      chunkSize: "chunk_size",
+      candidateSize: "candidate_size",
+      minCharactersPerChunk: "min_characters_per_chunk"
+    });
+  });
+  ((AgenticChunkerStrategy$) => {
+    AgenticChunkerStrategy$.inboundSchema = AgenticChunkerStrategy$inboundSchema;
+    AgenticChunkerStrategy$.outboundSchema = AgenticChunkerStrategy$outboundSchema;
+  })(AgenticChunkerStrategy$ ||= {});
+  ParseChunkingRequestChunkingRequestReturnType$inboundSchema = nativeEnumType(ParseChunkingRequestChunkingRequestReturnType);
+  ParseChunkingRequestChunkingRequestReturnType$outboundSchema = ParseChunkingRequestChunkingRequestReturnType$inboundSchema;
+  ((ParseChunkingRequestChunkingRequestReturnType$) => {
+    ParseChunkingRequestChunkingRequestReturnType$.inboundSchema = ParseChunkingRequestChunkingRequestReturnType$inboundSchema;
+    ParseChunkingRequestChunkingRequestReturnType$.outboundSchema = ParseChunkingRequestChunkingRequestReturnType$outboundSchema;
+  })(ParseChunkingRequestChunkingRequestReturnType$ ||= {});
+  SDPMChunker$inboundSchema = nativeEnumType(SDPMChunker);
+  SDPMChunker$outboundSchema = SDPMChunker$inboundSchema;
+  ((SDPMChunker$) => {
+    SDPMChunker$.inboundSchema = SDPMChunker$inboundSchema;
+    SDPMChunker$.outboundSchema = SDPMChunker$outboundSchema;
+  })(SDPMChunker$ ||= {});
+  ParseThreshold2$inboundSchema = nativeEnumType(ParseThreshold2);
+  ParseThreshold2$outboundSchema = ParseThreshold2$inboundSchema;
+  ((ParseThreshold2$) => {
+    ParseThreshold2$.inboundSchema = ParseThreshold2$inboundSchema;
+    ParseThreshold2$.outboundSchema = ParseThreshold2$outboundSchema;
+  })(ParseThreshold2$ ||= {});
+  ChunkingRequestThreshold$inboundSchema = unionType([numberType(), ParseThreshold2$inboundSchema]);
+  ChunkingRequestThreshold$outboundSchema = unionType([numberType(), ParseThreshold2$outboundSchema]);
+  ((ChunkingRequestThreshold$) => {
+    ChunkingRequestThreshold$.inboundSchema = ChunkingRequestThreshold$inboundSchema;
+    ChunkingRequestThreshold$.outboundSchema = ChunkingRequestThreshold$outboundSchema;
+  })(ChunkingRequestThreshold$ ||= {});
+  ChunkingRequestMode$inboundSchema = nativeEnumType(ChunkingRequestMode);
+  ChunkingRequestMode$outboundSchema = ChunkingRequestMode$inboundSchema;
+  ((ChunkingRequestMode$) => {
+    ChunkingRequestMode$.inboundSchema = ChunkingRequestMode$inboundSchema;
+    ChunkingRequestMode$.outboundSchema = ChunkingRequestMode$outboundSchema;
+  })(ChunkingRequestMode$ ||= {});
+  SDPMChunkerStrategy$inboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    return_type: ParseChunkingRequestChunkingRequestReturnType$inboundSchema.default("chunks"),
+    strategy: SDPMChunker$inboundSchema,
+    chunk_size: numberType().int().default(512),
+    skip_window: numberType().int().default(1),
+    threshold: unionType([numberType(), ParseThreshold2$inboundSchema]).optional(),
+    embedding_model: stringType(),
+    mode: ChunkingRequestMode$inboundSchema.default("window")
+  }).transform((v2) => {
+    return remap(v2, {
+      return_type: "returnType",
+      chunk_size: "chunkSize",
+      skip_window: "skipWindow",
+      embedding_model: "embeddingModel"
+    });
+  });
+  SDPMChunkerStrategy$outboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    returnType: ParseChunkingRequestChunkingRequestReturnType$outboundSchema.default("chunks"),
+    strategy: SDPMChunker$outboundSchema,
+    chunkSize: numberType().int().default(512),
+    skipWindow: numberType().int().default(1),
+    threshold: unionType([numberType(), ParseThreshold2$outboundSchema]).optional(),
+    embeddingModel: stringType(),
+    mode: ChunkingRequestMode$outboundSchema.default("window")
+  }).transform((v2) => {
+    return remap(v2, {
+      returnType: "return_type",
+      chunkSize: "chunk_size",
+      skipWindow: "skip_window",
+      embeddingModel: "embedding_model"
+    });
+  });
+  ((SDPMChunkerStrategy$) => {
+    SDPMChunkerStrategy$.inboundSchema = SDPMChunkerStrategy$inboundSchema;
+    SDPMChunkerStrategy$.outboundSchema = SDPMChunkerStrategy$outboundSchema;
+  })(SDPMChunkerStrategy$ ||= {});
+  ParseChunkingRequestChunkingReturnType$inboundSchema = nativeEnumType(ParseChunkingRequestChunkingReturnType);
+  ParseChunkingRequestChunkingReturnType$outboundSchema = ParseChunkingRequestChunkingReturnType$inboundSchema;
+  ((ParseChunkingRequestChunkingReturnType$) => {
+    ParseChunkingRequestChunkingReturnType$.inboundSchema = ParseChunkingRequestChunkingReturnType$inboundSchema;
+    ParseChunkingRequestChunkingReturnType$.outboundSchema = ParseChunkingRequestChunkingReturnType$outboundSchema;
+  })(ParseChunkingRequestChunkingReturnType$ ||= {});
+  SemanticChunker$inboundSchema = nativeEnumType(SemanticChunker);
+  SemanticChunker$outboundSchema = SemanticChunker$inboundSchema;
+  ((SemanticChunker$) => {
+    SemanticChunker$.inboundSchema = SemanticChunker$inboundSchema;
+    SemanticChunker$.outboundSchema = SemanticChunker$outboundSchema;
+  })(SemanticChunker$ ||= {});
+  Threshold2$inboundSchema = nativeEnumType(Threshold2);
+  Threshold2$outboundSchema = Threshold2$inboundSchema;
+  ((Threshold2$) => {
+    Threshold2$.inboundSchema = Threshold2$inboundSchema;
+    Threshold2$.outboundSchema = Threshold2$outboundSchema;
+  })(Threshold2$ ||= {});
+  Threshold$inboundSchema = unionType([numberType(), Threshold2$inboundSchema]);
+  Threshold$outboundSchema = unionType([numberType(), Threshold2$outboundSchema]);
+  ((Threshold$) => {
+    Threshold$.inboundSchema = Threshold$inboundSchema;
+    Threshold$.outboundSchema = Threshold$outboundSchema;
+  })(Threshold$ ||= {});
+  Mode$inboundSchema = nativeEnumType(Mode);
+  Mode$outboundSchema = Mode$inboundSchema;
+  ((Mode$) => {
+    Mode$.inboundSchema = Mode$inboundSchema;
+    Mode$.outboundSchema = Mode$outboundSchema;
+  })(Mode$ ||= {});
+  SemanticChunkerStrategy$inboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    return_type: ParseChunkingRequestChunkingReturnType$inboundSchema.default("chunks"),
+    strategy: SemanticChunker$inboundSchema,
+    chunk_size: numberType().int().default(512),
+    threshold: unionType([numberType(), Threshold2$inboundSchema]).optional(),
+    embedding_model: stringType(),
+    mode: Mode$inboundSchema.default("window"),
+    similarity_window: numberType().int().default(1)
+  }).transform((v2) => {
+    return remap(v2, {
+      return_type: "returnType",
+      chunk_size: "chunkSize",
+      embedding_model: "embeddingModel",
+      similarity_window: "similarityWindow"
+    });
+  });
+  SemanticChunkerStrategy$outboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    returnType: ParseChunkingRequestChunkingReturnType$outboundSchema.default("chunks"),
+    strategy: SemanticChunker$outboundSchema,
+    chunkSize: numberType().int().default(512),
+    threshold: unionType([numberType(), Threshold2$outboundSchema]).optional(),
+    embeddingModel: stringType(),
+    mode: Mode$outboundSchema.default("window"),
+    similarityWindow: numberType().int().default(1)
+  }).transform((v2) => {
+    return remap(v2, {
+      returnType: "return_type",
+      chunkSize: "chunk_size",
+      embeddingModel: "embedding_model",
+      similarityWindow: "similarity_window"
+    });
+  });
+  ((SemanticChunkerStrategy$) => {
+    SemanticChunkerStrategy$.inboundSchema = SemanticChunkerStrategy$inboundSchema;
+    SemanticChunkerStrategy$.outboundSchema = SemanticChunkerStrategy$outboundSchema;
+  })(SemanticChunkerStrategy$ ||= {});
+  ParseChunkingRequestReturnType$inboundSchema = nativeEnumType(ParseChunkingRequestReturnType);
+  ParseChunkingRequestReturnType$outboundSchema = ParseChunkingRequestReturnType$inboundSchema;
+  ((ParseChunkingRequestReturnType$) => {
+    ParseChunkingRequestReturnType$.inboundSchema = ParseChunkingRequestReturnType$inboundSchema;
+    ParseChunkingRequestReturnType$.outboundSchema = ParseChunkingRequestReturnType$outboundSchema;
+  })(ParseChunkingRequestReturnType$ ||= {});
+  RecursiveChunker$inboundSchema = nativeEnumType(RecursiveChunker);
+  RecursiveChunker$outboundSchema = RecursiveChunker$inboundSchema;
+  ((RecursiveChunker$) => {
+    RecursiveChunker$.inboundSchema = RecursiveChunker$inboundSchema;
+    RecursiveChunker$.outboundSchema = RecursiveChunker$outboundSchema;
+  })(RecursiveChunker$ ||= {});
+  RecursiveChunkerStrategy$inboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    return_type: ParseChunkingRequestReturnType$inboundSchema.default("chunks"),
+    strategy: RecursiveChunker$inboundSchema,
+    chunk_size: numberType().int().default(512),
+    separators: arrayType(stringType()).optional(),
+    min_characters_per_chunk: numberType().int().default(24)
+  }).transform((v2) => {
+    return remap(v2, {
+      return_type: "returnType",
+      chunk_size: "chunkSize",
+      min_characters_per_chunk: "minCharactersPerChunk"
+    });
+  });
+  RecursiveChunkerStrategy$outboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    returnType: ParseChunkingRequestReturnType$outboundSchema.default("chunks"),
+    strategy: RecursiveChunker$outboundSchema,
+    chunkSize: numberType().int().default(512),
+    separators: arrayType(stringType()).optional(),
+    minCharactersPerChunk: numberType().int().default(24)
+  }).transform((v2) => {
+    return remap(v2, {
+      returnType: "return_type",
+      chunkSize: "chunk_size",
+      minCharactersPerChunk: "min_characters_per_chunk"
+    });
+  });
+  ((RecursiveChunkerStrategy$) => {
+    RecursiveChunkerStrategy$.inboundSchema = RecursiveChunkerStrategy$inboundSchema;
+    RecursiveChunkerStrategy$.outboundSchema = RecursiveChunkerStrategy$outboundSchema;
+  })(RecursiveChunkerStrategy$ ||= {});
+  ChunkingRequestReturnType$inboundSchema = nativeEnumType(ChunkingRequestReturnType);
+  ChunkingRequestReturnType$outboundSchema = ChunkingRequestReturnType$inboundSchema;
+  ((ChunkingRequestReturnType$) => {
+    ChunkingRequestReturnType$.inboundSchema = ChunkingRequestReturnType$inboundSchema;
+    ChunkingRequestReturnType$.outboundSchema = ChunkingRequestReturnType$outboundSchema;
+  })(ChunkingRequestReturnType$ ||= {});
+  SentenceChunker$inboundSchema = nativeEnumType(SentenceChunker);
+  SentenceChunker$outboundSchema = SentenceChunker$inboundSchema;
+  ((SentenceChunker$) => {
+    SentenceChunker$.inboundSchema = SentenceChunker$inboundSchema;
+    SentenceChunker$.outboundSchema = SentenceChunker$outboundSchema;
+  })(SentenceChunker$ ||= {});
+  SentenceChunkerStrategy$inboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    return_type: ChunkingRequestReturnType$inboundSchema.default("chunks"),
+    strategy: SentenceChunker$inboundSchema,
+    chunk_size: numberType().int().default(512),
+    chunk_overlap: numberType().int().default(0),
+    min_sentences_per_chunk: numberType().int().default(1)
+  }).transform((v2) => {
+    return remap(v2, {
+      return_type: "returnType",
+      chunk_size: "chunkSize",
+      chunk_overlap: "chunkOverlap",
+      min_sentences_per_chunk: "minSentencesPerChunk"
+    });
+  });
+  SentenceChunkerStrategy$outboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    returnType: ChunkingRequestReturnType$outboundSchema.default("chunks"),
+    strategy: SentenceChunker$outboundSchema,
+    chunkSize: numberType().int().default(512),
+    chunkOverlap: numberType().int().default(0),
+    minSentencesPerChunk: numberType().int().default(1)
+  }).transform((v2) => {
+    return remap(v2, {
+      returnType: "return_type",
+      chunkSize: "chunk_size",
+      chunkOverlap: "chunk_overlap",
+      minSentencesPerChunk: "min_sentences_per_chunk"
+    });
+  });
+  ((SentenceChunkerStrategy$) => {
+    SentenceChunkerStrategy$.inboundSchema = SentenceChunkerStrategy$inboundSchema;
+    SentenceChunkerStrategy$.outboundSchema = SentenceChunkerStrategy$outboundSchema;
+  })(SentenceChunkerStrategy$ ||= {});
+  ReturnTypeT$inboundSchema = nativeEnumType(ReturnTypeT);
+  ReturnTypeT$outboundSchema = ReturnTypeT$inboundSchema;
+  ((ReturnTypeT$) => {
+    ReturnTypeT$.inboundSchema = ReturnTypeT$inboundSchema;
+    ReturnTypeT$.outboundSchema = ReturnTypeT$outboundSchema;
+  })(ReturnTypeT$ ||= {});
+  TokenChunker$inboundSchema = nativeEnumType(TokenChunker);
+  TokenChunker$outboundSchema = TokenChunker$inboundSchema;
+  ((TokenChunker$) => {
+    TokenChunker$.inboundSchema = TokenChunker$inboundSchema;
+    TokenChunker$.outboundSchema = TokenChunker$outboundSchema;
+  })(TokenChunker$ ||= {});
+  TokenChunkerStrategy$inboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    return_type: ReturnTypeT$inboundSchema.default("chunks"),
+    strategy: TokenChunker$inboundSchema,
+    chunk_size: numberType().int().default(512),
+    chunk_overlap: numberType().int().default(0)
+  }).transform((v2) => {
+    return remap(v2, {
+      return_type: "returnType",
+      chunk_size: "chunkSize",
+      chunk_overlap: "chunkOverlap"
+    });
+  });
+  TokenChunkerStrategy$outboundSchema = objectType({
+    text: stringType(),
+    metadata: booleanType().default(true),
+    returnType: ReturnTypeT$outboundSchema.default("chunks"),
+    strategy: TokenChunker$outboundSchema,
+    chunkSize: numberType().int().default(512),
+    chunkOverlap: numberType().int().default(0)
+  }).transform((v2) => {
+    return remap(v2, {
+      returnType: "return_type",
+      chunkSize: "chunk_size",
+      chunkOverlap: "chunk_overlap"
+    });
+  });
+  ((TokenChunkerStrategy$) => {
+    TokenChunkerStrategy$.inboundSchema = TokenChunkerStrategy$inboundSchema;
+    TokenChunkerStrategy$.outboundSchema = TokenChunkerStrategy$outboundSchema;
+  })(TokenChunkerStrategy$ ||= {});
+  ParseChunkingRequest$inboundSchema = unionType([
+    lazyType(() => SemanticChunkerStrategy$inboundSchema),
+    lazyType(() => SDPMChunkerStrategy$inboundSchema),
+    lazyType(() => AgenticChunkerStrategy$inboundSchema),
+    lazyType(() => TokenChunkerStrategy$inboundSchema),
+    lazyType(() => SentenceChunkerStrategy$inboundSchema),
+    lazyType(() => RecursiveChunkerStrategy$inboundSchema)
+  ]);
+  ParseChunkingRequest$outboundSchema = unionType([
+    lazyType(() => SemanticChunkerStrategy$outboundSchema),
+    lazyType(() => SDPMChunkerStrategy$outboundSchema),
+    lazyType(() => AgenticChunkerStrategy$outboundSchema),
+    lazyType(() => TokenChunkerStrategy$outboundSchema),
+    lazyType(() => SentenceChunkerStrategy$outboundSchema),
+    lazyType(() => RecursiveChunkerStrategy$outboundSchema)
+  ]);
+  ((ParseChunkingRequest$) => {
+    ParseChunkingRequest$.inboundSchema = ParseChunkingRequest$inboundSchema;
+    ParseChunkingRequest$.outboundSchema = ParseChunkingRequest$outboundSchema;
+  })(ParseChunkingRequest$ ||= {});
+  ParseMetadata$inboundSchema = objectType({
+    start_index: nullableType(numberType()),
+    end_index: nullableType(numberType()),
+    token_count: nullableType(numberType())
+  }).transform((v2) => {
+    return remap(v2, {
+      start_index: "startIndex",
+      end_index: "endIndex",
+      token_count: "tokenCount"
+    });
+  });
+  ParseMetadata$outboundSchema = objectType({
+    startIndex: nullableType(numberType()),
+    endIndex: nullableType(numberType()),
+    tokenCount: nullableType(numberType())
+  }).transform((v2) => {
+    return remap(v2, {
+      startIndex: "start_index",
+      endIndex: "end_index",
+      tokenCount: "token_count"
+    });
+  });
+  ((ParseMetadata$) => {
+    ParseMetadata$.inboundSchema = ParseMetadata$inboundSchema;
+    ParseMetadata$.outboundSchema = ParseMetadata$outboundSchema;
+  })(ParseMetadata$ ||= {});
+  Chunks$inboundSchema = objectType({
+    text: stringType(),
+    index: numberType(),
+    metadata: lazyType(() => ParseMetadata$inboundSchema).optional()
+  });
+  Chunks$outboundSchema = objectType({
+    text: stringType(),
+    index: numberType(),
+    metadata: lazyType(() => ParseMetadata$outboundSchema).optional()
+  });
+  ((Chunks$) => {
+    Chunks$.inboundSchema = Chunks$inboundSchema;
+    Chunks$.outboundSchema = Chunks$outboundSchema;
+  })(Chunks$ ||= {});
+  ParseResponseBody$inboundSchema = objectType({
+    chunks: arrayType(lazyType(() => Chunks$inboundSchema))
+  });
+  ParseResponseBody$outboundSchema = objectType({
+    chunks: arrayType(lazyType(() => Chunks$outboundSchema))
+  });
+  ((ParseResponseBody$) => {
+    ParseResponseBody$.inboundSchema = ParseResponseBody$inboundSchema;
+    ParseResponseBody$.outboundSchema = ParseResponseBody$outboundSchema;
+  })(ParseResponseBody$ ||= {});
+});
+
 // src/models/operations/remoteconfigsgetconfig.ts
 var RemoteConfigsGetConfigType, RemoteConfigsGetConfigRequestBody$inboundSchema, RemoteConfigsGetConfigRequestBody$outboundSchema, RemoteConfigsGetConfigRequestBody$, RemoteConfigsGetConfigType$inboundSchema, RemoteConfigsGetConfigType$outboundSchema, RemoteConfigsGetConfigType$, RemoteConfigsGetConfigResponseBody$inboundSchema, RemoteConfigsGetConfigResponseBody$outboundSchema, RemoteConfigsGetConfigResponseBody$;
 var init_remoteconfigsgetconfig = __esm(() => {
@@ -55031,7 +55492,7 @@ var init_retrievecontact = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -55049,7 +55510,7 @@ var init_retrievecontact = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -55626,7 +56087,7 @@ var init_retrievedatapoint = __esm(() => {
     created_by_id: stringType().optional(),
     updated_by_id: stringType().optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -55653,7 +56114,7 @@ var init_retrievedatapoint = __esm(() => {
     createdById: stringType().optional(),
     updatedById: stringType().optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -55724,7 +56185,7 @@ var init_retrievedataset = __esm(() => {
     updated_by_id: stringType().optional(),
     metadata: lazyType(() => RetrieveDatasetMetadata$inboundSchema),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -55744,7 +56205,7 @@ var init_retrievedataset = __esm(() => {
     updatedById: stringType().optional(),
     metadata: lazyType(() => RetrieveDatasetMetadata$outboundSchema),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -55802,7 +56263,7 @@ var init_retrievedatasource = __esm(() => {
     RetrieveDatasourceStatus$.outboundSchema = RetrieveDatasourceStatus$outboundSchema;
   })(RetrieveDatasourceStatus$ ||= {});
   RetrieveDatasourceResponseBody$inboundSchema = objectType({
-    _id: stringType().default("01JZR9S4ZPNFA48VJ7A8H87432"),
+    _id: stringType().default("01JZRA0D8F7P4JQ5JDZQMF2RDC"),
     display_name: stringType(),
     description: stringType().optional(),
     status: RetrieveDatasourceStatus$inboundSchema,
@@ -55825,7 +56286,7 @@ var init_retrievedatasource = __esm(() => {
     });
   });
   RetrieveDatasourceResponseBody$outboundSchema = objectType({
-    id: stringType().default("01JZR9S4ZPNFA48VJ7A8H87432"),
+    id: stringType().default("01JZRA0D8F7P4JQ5JDZQMF2RDC"),
     displayName: stringType(),
     description: stringType().optional(),
     status: RetrieveDatasourceStatus$outboundSchema,
@@ -56706,7 +57167,7 @@ var init_updatecontact = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -56724,7 +57185,7 @@ var init_updatecontact = __esm(() => {
     tags: arrayType(stringType()).optional(),
     metadata: recordType(anyType()).optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -57858,7 +58319,7 @@ var init_updatedatapoint = __esm(() => {
     created_by_id: stringType().optional(),
     updated_by_id: stringType().optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -57885,7 +58346,7 @@ var init_updatedatapoint = __esm(() => {
     createdById: stringType().optional(),
     updatedById: stringType().optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -57986,7 +58447,7 @@ var init_updatedataset = __esm(() => {
     parent_id: stringType().optional(),
     version: stringType().optional(),
     created: stringType().datetime({ offset: true }).transform((v2) => new Date(v2)).optional(),
-    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:14:34.200Z").transform((v2) => new Date(v2))
+    updated: stringType().datetime({ offset: true }).default("2025-07-09T19:18:32.412Z").transform((v2) => new Date(v2))
   }).transform((v2) => {
     return remap(v2, {
       _id: "id",
@@ -58009,7 +58470,7 @@ var init_updatedataset = __esm(() => {
     parentId: stringType().optional(),
     version: stringType().optional(),
     created: dateType().transform((v2) => v2.toISOString()).optional(),
-    updated: dateType().default(() => new Date("2025-07-09T19:14:34.200Z")).transform((v2) => v2.toISOString())
+    updated: dateType().default(() => new Date("2025-07-09T19:18:32.412Z")).transform((v2) => v2.toISOString())
   }).transform((v2) => {
     return remap(v2, {
       id: "_id",
@@ -58090,7 +58551,7 @@ var init_updatedatasource = __esm(() => {
     UpdateDatasourceStatus$.outboundSchema = UpdateDatasourceStatus$outboundSchema;
   })(UpdateDatasourceStatus$ ||= {});
   UpdateDatasourceResponseBody$inboundSchema = objectType({
-    _id: stringType().default("01JZR9S4ZQ9R9PDN34898FBAHC"),
+    _id: stringType().default("01JZRA0D8H931XQJ8MBR2VQHM8"),
     display_name: stringType(),
     description: stringType().optional(),
     status: UpdateDatasourceStatus$inboundSchema,
@@ -58113,7 +58574,7 @@ var init_updatedatasource = __esm(() => {
     });
   });
   UpdateDatasourceResponseBody$outboundSchema = objectType({
-    id: stringType().default("01JZR9S4ZQ9R9PDN34898FBAHC"),
+    id: stringType().default("01JZRA0D8H931XQJ8MBR2VQHM8"),
     displayName: stringType(),
     description: stringType().optional(),
     status: UpdateDatasourceStatus$outboundSchema,
@@ -58819,8 +59280,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyPython$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$inboundSchema)
@@ -58837,8 +59298,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyPython$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$outboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$outboundSchema)
@@ -58931,8 +59392,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyHTTP$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$inboundSchema)
@@ -58952,8 +59413,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyHTTP$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$outboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$outboundSchema)
@@ -59043,8 +59504,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyJSON$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200Number$inboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200Boolean$inboundSchema)
@@ -59061,8 +59522,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyJSON$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200Number$outboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponse200Boolean$outboundSchema)
@@ -59149,8 +59610,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyLLM$inboundSchema = objectType({
     _id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrail_config: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponseNumber$inboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponseBoolean$inboundSchema)
@@ -59168,8 +59629,8 @@ var init_updateeval = __esm(() => {
   UpdateEvalResponseBodyLLM$outboundSchema = objectType({
     id: stringType(),
     description: stringType(),
-    created: stringType().default("2025-07-09T19:14:36.589Z"),
-    updated: stringType().default("2025-07-09T19:14:36.589Z"),
+    created: stringType().default("2025-07-09T19:18:34.538Z"),
+    updated: stringType().default("2025-07-09T19:18:34.538Z"),
     guardrailConfig: unionType([
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponseNumber$outboundSchema),
       lazyType(() => UpdateEvalGuardrailConfigEvalsResponseBoolean$outboundSchema)
@@ -60753,6 +61214,7 @@ var init_operations = __esm(() => {
   init_listknowledgebases();
   init_listmodels();
   init_listpromptversions();
+  init_parse();
   init_remoteconfigsgetconfig();
   init_retrievecontact();
   init_retrievedatapoint();
@@ -60795,11 +61257,110 @@ var init_async = __esm(() => {
   };
 });
 
-// src/funcs/contactsCreate.ts
-function contactsCreate(client, request, options) {
+// src/funcs/chunkingParse.ts
+function chunkingParse(client, request, options) {
   return new APIPromise($do(client, request, options));
 }
 async function $do(client, request, options) {
+  const parsed = safeParse(request, (value) => ParseChunkingRequest$outboundSchema.parse(value), "Input validation failed");
+  if (!parsed.ok) {
+    return [parsed, { status: "invalid" }];
+  }
+  const payload = parsed.value;
+  const body = encodeJSON("body", payload, { explode: true });
+  const path = pathToFunc("/v2/chunking")();
+  const headers = new Headers(compactMap({
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  }));
+  const secConfig = await extractSecurity(client._options.apiKey);
+  const securityInput = secConfig == null ? {} : { apiKey: secConfig };
+  const requestSecurity = resolveGlobalSecurity(securityInput);
+  const context = {
+    options: client._options,
+    baseURL: options?.serverURL ?? client._baseURL ?? "",
+    operationID: "parse",
+    oAuth2Scopes: [],
+    resolvedSecurity: requestSecurity,
+    securitySource: client._options.apiKey,
+    retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
+    retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
+  };
+  const requestRes = client._createRequest(context, {
+    security: requestSecurity,
+    method: "POST",
+    baseURL: options?.serverURL,
+    path,
+    headers,
+    body,
+    userAgent: client._options.userAgent,
+    timeoutMs: options?.timeoutMs || client._options.timeoutMs || 600000
+  }, options);
+  if (!requestRes.ok) {
+    return [requestRes, { status: "invalid" }];
+  }
+  const req = requestRes.value;
+  const doResult = await client._do(req, {
+    context,
+    errorCodes: ["4XX", "5XX"],
+    retryConfig: context.retryConfig,
+    retryCodes: context.retryCodes
+  });
+  if (!doResult.ok) {
+    return [doResult, { status: "request-error", request: req }];
+  }
+  const response = doResult.value;
+  const [result] = await match(json(200, ParseResponseBody$inboundSchema), fail("4XX"), fail("5XX"))(response, req);
+  if (!result.ok) {
+    return [result, { status: "complete", request: req, response }];
+  }
+  return [result, { status: "complete", request: req, response }];
+}
+var init_chunkingParse = __esm(() => {
+  init_encodings();
+  init_matchers();
+  init_primitives();
+  init_schemas();
+  init_security();
+  init_url();
+  init_operations();
+  init_async();
+});
+
+// src/mcp-server/tools/chunkingParse.ts
+var args, tool$chunkingParse;
+var init_chunkingParse2 = __esm(() => {
+  init_chunkingParse();
+  init_operations();
+  init_tools();
+  args = {
+    request: ParseChunkingRequest$inboundSchema
+  };
+  tool$chunkingParse = {
+    name: "chunking-parse",
+    description: `Parse text
+
+Split large text documents into smaller, manageable chunks using different chunking strategies optimized for RAG (Retrieval-Augmented Generation) workflows. This endpoint supports multiple chunking algorithms including token-based, sentence-based, recursive, semantic, and specialized strategies.`,
+    args,
+    tool: async (client, args2, ctx) => {
+      const [result, apiCall] = await chunkingParse(client, args2.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error.message }],
+          isError: true
+        };
+      }
+      const value = result.value;
+      return formatResult(value, apiCall);
+    }
+  };
+});
+
+// src/funcs/contactsCreate.ts
+function contactsCreate(client, request, options) {
+  return new APIPromise($do2(client, request, options));
+}
+async function $do2(client, request, options) {
   const parsed = safeParse(request, (value) => CreateContactRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -60866,12 +61427,12 @@ var init_contactsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/contactsCreate.ts
-var args, tool$contactsCreate;
+var args2, tool$contactsCreate;
 var init_contactsCreate2 = __esm(() => {
   init_contactsCreate();
   init_operations();
   init_tools();
-  args = {
+  args2 = {
     request: CreateContactRequestBody$inboundSchema.optional()
   };
   tool$contactsCreate = {
@@ -60879,9 +61440,9 @@ var init_contactsCreate2 = __esm(() => {
     description: `Create a contact
 
 Creates a new contact or updates an existing one based on external_id. Use this endpoint to add users from your system to orq.ai for tracking their usage and engagement.`,
-    args,
-    tool: async (client, args2, ctx) => {
-      const [result, apiCall] = await contactsCreate(client, args2.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args2,
+    tool: async (client, args3, ctx) => {
+      const [result, apiCall] = await contactsCreate(client, args3.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63705,9 +64266,9 @@ var init_errors2 = __esm(() => {
 
 // src/funcs/contactsDelete.ts
 function contactsDelete(client, request, options) {
-  return new APIPromise($do2(client, request, options));
+  return new APIPromise($do3(client, request, options));
 }
-async function $do2(client, request, options) {
+async function $do3(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteContactRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63784,12 +64345,12 @@ var init_contactsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/contactsDelete.ts
-var args2, tool$contactsDelete;
+var args3, tool$contactsDelete;
 var init_contactsDelete2 = __esm(() => {
   init_contactsDelete();
   init_operations();
   init_tools();
-  args2 = {
+  args3 = {
     request: DeleteContactRequest$inboundSchema
   };
   tool$contactsDelete = {
@@ -63797,9 +64358,9 @@ var init_contactsDelete2 = __esm(() => {
     description: `Delete a contact
 
 Permanently deletes a contact from your workspace. This action cannot be undone.`,
-    args: args2,
-    tool: async (client, args3, ctx) => {
-      const [result, apiCall] = await contactsDelete(client, args3.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args3,
+    tool: async (client, args4, ctx) => {
+      const [result, apiCall] = await contactsDelete(client, args4.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63813,9 +64374,9 @@ Permanently deletes a contact from your workspace. This action cannot be undone.
 
 // src/funcs/contactsList.ts
 function contactsList(client, request, options) {
-  return new APIPromise($do3(client, request, options));
+  return new APIPromise($do4(client, request, options));
 }
-async function $do3(client, request, options) {
+async function $do4(client, request, options) {
   const parsed = safeParse(request, (value) => ListContactsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63889,12 +64450,12 @@ var init_contactsList = __esm(() => {
 });
 
 // src/mcp-server/tools/contactsList.ts
-var args3, tool$contactsList;
+var args4, tool$contactsList;
 var init_contactsList2 = __esm(() => {
   init_contactsList();
   init_operations();
   init_tools();
-  args3 = {
+  args4 = {
     request: ListContactsRequest$inboundSchema.optional()
   };
   tool$contactsList = {
@@ -63902,9 +64463,9 @@ var init_contactsList2 = __esm(() => {
     description: `List contacts
 
 Retrieves a paginated list of contacts in your workspace. Use pagination parameters to navigate through large contact lists efficiently.`,
-    args: args3,
-    tool: async (client, args4, ctx) => {
-      const [result, apiCall] = await contactsList(client, args4.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args4,
+    tool: async (client, args5, ctx) => {
+      const [result, apiCall] = await contactsList(client, args5.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -63919,9 +64480,9 @@ Retrieves a paginated list of contacts in your workspace. Use pagination paramet
 
 // src/funcs/contactsRetrieve.ts
 function contactsRetrieve(client, request, options) {
-  return new APIPromise($do4(client, request, options));
+  return new APIPromise($do5(client, request, options));
 }
-async function $do4(client, request, options) {
+async function $do5(client, request, options) {
   const parsed = safeParse(request, (value) => RetrieveContactRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -63997,12 +64558,12 @@ var init_contactsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/contactsRetrieve.ts
-var args4, tool$contactsRetrieve;
+var args5, tool$contactsRetrieve;
 var init_contactsRetrieve2 = __esm(() => {
   init_contactsRetrieve();
   init_operations();
   init_tools();
-  args4 = {
+  args5 = {
     request: RetrieveContactRequest$inboundSchema
   };
   tool$contactsRetrieve = {
@@ -64010,9 +64571,9 @@ var init_contactsRetrieve2 = __esm(() => {
     description: `Retrieve a contact
 
 Retrieves detailed information about a specific contact using their contact ID or external ID from your system.`,
-    args: args4,
-    tool: async (client, args5, ctx) => {
-      const [result, apiCall] = await contactsRetrieve(client, args5.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args5,
+    tool: async (client, args6, ctx) => {
+      const [result, apiCall] = await contactsRetrieve(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64027,9 +64588,9 @@ Retrieves detailed information about a specific contact using their contact ID o
 
 // src/funcs/contactsUpdate.ts
 function contactsUpdate(client, request, options) {
-  return new APIPromise($do5(client, request, options));
+  return new APIPromise($do6(client, request, options));
 }
-async function $do5(client, request, options) {
+async function $do6(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateContactRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64106,12 +64667,12 @@ var init_contactsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/contactsUpdate.ts
-var args5, tool$contactsUpdate;
+var args6, tool$contactsUpdate;
 var init_contactsUpdate2 = __esm(() => {
   init_contactsUpdate();
   init_operations();
   init_tools();
-  args5 = {
+  args6 = {
     request: UpdateContactRequest$inboundSchema
   };
   tool$contactsUpdate = {
@@ -64119,9 +64680,9 @@ var init_contactsUpdate2 = __esm(() => {
     description: `Update a contact
 
 Updates specific fields of an existing contact. Only the fields provided in the request body will be updated.`,
-    args: args5,
-    tool: async (client, args6, ctx) => {
-      const [result, apiCall] = await contactsUpdate(client, args6.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args6,
+    tool: async (client, args7, ctx) => {
+      const [result, apiCall] = await contactsUpdate(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64136,9 +64697,9 @@ Updates specific fields of an existing contact. Only the fields provided in the
 
 // src/funcs/datasetsClear.ts
 function datasetsClear(client, request, options) {
-  return new APIPromise($do6(client, request, options));
+  return new APIPromise($do7(client, request, options));
 }
-async function $do6(client, request, options) {
+async function $do7(client, request, options) {
   const parsed = safeParse(request, (value) => ClearDatasetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64211,12 +64772,12 @@ var init_datasetsClear = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsClear.ts
-var args6, tool$datasetsClear;
+var args7, tool$datasetsClear;
 var init_datasetsClear2 = __esm(() => {
   init_datasetsClear();
   init_operations();
   init_tools();
-  args6 = {
+  args7 = {
     request: ClearDatasetRequest$inboundSchema
   };
   tool$datasetsClear = {
@@ -64224,9 +64785,9 @@ var init_datasetsClear2 = __esm(() => {
     description: `Delete all datapoints
 
 Delete all datapoints from a dataset. This action is irreversible.`,
-    args: args6,
-    tool: async (client, args7, ctx) => {
-      const [result, apiCall] = await datasetsClear(client, args7.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args7,
+    tool: async (client, args8, ctx) => {
+      const [result, apiCall] = await datasetsClear(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64240,9 +64801,9 @@ Delete all datapoints from a dataset. This action is irreversible.`,
 
 // src/funcs/datasetsCreate.ts
 function datasetsCreate(client, request, options) {
-  return new APIPromise($do7(client, request, options));
+  return new APIPromise($do8(client, request, options));
 }
-async function $do7(client, request, options) {
+async function $do8(client, request, options) {
   const parsed = safeParse(request, (value) => CreateDatasetRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64309,12 +64870,12 @@ var init_datasetsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsCreate.ts
-var args7, tool$datasetsCreate;
+var args8, tool$datasetsCreate;
 var init_datasetsCreate2 = __esm(() => {
   init_datasetsCreate();
   init_operations();
   init_tools();
-  args7 = {
+  args8 = {
     request: CreateDatasetRequestBody$inboundSchema.optional()
   };
   tool$datasetsCreate = {
@@ -64322,9 +64883,9 @@ var init_datasetsCreate2 = __esm(() => {
     description: `Create a dataset
 
 Creates a new dataset in the specified project.`,
-    args: args7,
-    tool: async (client, args8, ctx) => {
-      const [result, apiCall] = await datasetsCreate(client, args8.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args8,
+    tool: async (client, args9, ctx) => {
+      const [result, apiCall] = await datasetsCreate(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64339,9 +64900,9 @@ Creates a new dataset in the specified project.`,
 
 // src/funcs/datasetsCreateDatapoint.ts
 function datasetsCreateDatapoint(client, request, options) {
-  return new APIPromise($do8(client, request, options));
+  return new APIPromise($do9(client, request, options));
 }
-async function $do8(client, request, options) {
+async function $do9(client, request, options) {
   const parsed = safeParse(request, (value) => CreateDatasetItemRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64414,12 +64975,12 @@ var init_datasetsCreateDatapoint = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsCreateDatapoint.ts
-var args8, tool$datasetsCreateDatapoint;
+var args9, tool$datasetsCreateDatapoint;
 var init_datasetsCreateDatapoint2 = __esm(() => {
   init_datasetsCreateDatapoint();
   init_operations();
   init_tools();
-  args8 = {
+  args9 = {
     request: CreateDatasetItemRequest$inboundSchema
   };
   tool$datasetsCreateDatapoint = {
@@ -64427,9 +64988,9 @@ var init_datasetsCreateDatapoint2 = __esm(() => {
     description: `Create a datapoint
 
 Creates a new datapoint in the specified dataset.`,
-    args: args8,
-    tool: async (client, args9, ctx) => {
-      const [result, apiCall] = await datasetsCreateDatapoint(client, args9.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args9,
+    tool: async (client, args10, ctx) => {
+      const [result, apiCall] = await datasetsCreateDatapoint(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64444,9 +65005,9 @@ Creates a new datapoint in the specified dataset.`,
 
 // src/funcs/datasetsDelete.ts
 function datasetsDelete(client, request, options) {
-  return new APIPromise($do9(client, request, options));
+  return new APIPromise($do10(client, request, options));
 }
-async function $do9(client, request, options) {
+async function $do10(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteDatasetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64519,12 +65080,12 @@ var init_datasetsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsDelete.ts
-var args9, tool$datasetsDelete;
+var args10, tool$datasetsDelete;
 var init_datasetsDelete2 = __esm(() => {
   init_datasetsDelete();
   init_operations();
   init_tools();
-  args9 = {
+  args10 = {
     request: DeleteDatasetRequest$inboundSchema
   };
   tool$datasetsDelete = {
@@ -64532,9 +65093,9 @@ var init_datasetsDelete2 = __esm(() => {
     description: `Delete a dataset
 
 Permanently deletes a dataset and all its datapoints. This action is irreversible.`,
-    args: args9,
-    tool: async (client, args10, ctx) => {
-      const [result, apiCall] = await datasetsDelete(client, args10.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args10,
+    tool: async (client, args11, ctx) => {
+      const [result, apiCall] = await datasetsDelete(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64548,9 +65109,9 @@ Permanently deletes a dataset and all its datapoints. This action is irreversibl
 
 // src/funcs/datasetsDeleteDatapoint.ts
 function datasetsDeleteDatapoint(client, request, options) {
-  return new APIPromise($do10(client, request, options));
+  return new APIPromise($do11(client, request, options));
 }
-async function $do10(client, request, options) {
+async function $do11(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteDatapointRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64631,12 +65192,12 @@ var init_datasetsDeleteDatapoint = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsDeleteDatapoint.ts
-var args10, tool$datasetsDeleteDatapoint;
+var args11, tool$datasetsDeleteDatapoint;
 var init_datasetsDeleteDatapoint2 = __esm(() => {
   init_datasetsDeleteDatapoint();
   init_operations();
   init_tools();
-  args10 = {
+  args11 = {
     request: DeleteDatapointRequest$inboundSchema
   };
   tool$datasetsDeleteDatapoint = {
@@ -64644,9 +65205,9 @@ var init_datasetsDeleteDatapoint2 = __esm(() => {
     description: `Delete a datapoint
 
 Permanently deletes a specific datapoint from a dataset.`,
-    args: args10,
-    tool: async (client, args11, ctx) => {
-      const [result, apiCall] = await datasetsDeleteDatapoint(client, args11.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args11,
+    tool: async (client, args12, ctx) => {
+      const [result, apiCall] = await datasetsDeleteDatapoint(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64660,9 +65221,9 @@ Permanently deletes a specific datapoint from a dataset.`,
 
 // src/funcs/datasetsList.ts
 function datasetsList(client, request, options) {
-  return new APIPromise($do11(client, request, options));
+  return new APIPromise($do12(client, request, options));
 }
-async function $do11(client, request, options) {
+async function $do12(client, request, options) {
   const parsed = safeParse(request, (value) => ListDatasetsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64734,12 +65295,12 @@ var init_datasetsList = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsList.ts
-var args11, tool$datasetsList;
+var args12, tool$datasetsList;
 var init_datasetsList2 = __esm(() => {
   init_datasetsList();
   init_operations();
   init_tools();
-  args11 = {
+  args12 = {
     request: ListDatasetsRequest$inboundSchema.optional()
   };
   tool$datasetsList = {
@@ -64747,9 +65308,9 @@ var init_datasetsList2 = __esm(() => {
     description: `List datasets
 
 Retrieves a paginated list of datasets for the current workspace. Results can be paginated using cursor-based pagination.`,
-    args: args11,
-    tool: async (client, args12, ctx) => {
-      const [result, apiCall] = await datasetsList(client, args12.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args12,
+    tool: async (client, args13, ctx) => {
+      const [result, apiCall] = await datasetsList(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64764,9 +65325,9 @@ Retrieves a paginated list of datasets for the current workspace. Results can be
 
 // src/funcs/datasetsListDatapoints.ts
 function datasetsListDatapoints(client, request, options) {
-  return new APIPromise($do12(client, request, options));
+  return new APIPromise($do13(client, request, options));
 }
-async function $do12(client, request, options) {
+async function $do13(client, request, options) {
   const parsed = safeParse(request, (value) => ListDatasetDatapointsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64844,12 +65405,12 @@ var init_datasetsListDatapoints = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsListDatapoints.ts
-var args12, tool$datasetsListDatapoints;
+var args13, tool$datasetsListDatapoints;
 var init_datasetsListDatapoints2 = __esm(() => {
   init_datasetsListDatapoints();
   init_operations();
   init_tools();
-  args12 = {
+  args13 = {
     request: ListDatasetDatapointsRequest$inboundSchema
   };
   tool$datasetsListDatapoints = {
@@ -64857,9 +65418,9 @@ var init_datasetsListDatapoints2 = __esm(() => {
     description: `List datapoints
 
 Retrieves a paginated list of datapoints from a specific dataset.`,
-    args: args12,
-    tool: async (client, args13, ctx) => {
-      const [result, apiCall] = await datasetsListDatapoints(client, args13.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args13,
+    tool: async (client, args14, ctx) => {
+      const [result, apiCall] = await datasetsListDatapoints(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64874,9 +65435,9 @@ Retrieves a paginated list of datapoints from a specific dataset.`,
 
 // src/funcs/datasetsRetrieve.ts
 function datasetsRetrieve(client, request, options) {
-  return new APIPromise($do13(client, request, options));
+  return new APIPromise($do14(client, request, options));
 }
-async function $do13(client, request, options) {
+async function $do14(client, request, options) {
   const parsed = safeParse(request, (value) => RetrieveDatasetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -64952,12 +65513,12 @@ var init_datasetsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsRetrieve.ts
-var args13, tool$datasetsRetrieve;
+var args14, tool$datasetsRetrieve;
 var init_datasetsRetrieve2 = __esm(() => {
   init_datasetsRetrieve();
   init_operations();
   init_tools();
-  args13 = {
+  args14 = {
     request: RetrieveDatasetRequest$inboundSchema
   };
   tool$datasetsRetrieve = {
@@ -64965,9 +65526,9 @@ var init_datasetsRetrieve2 = __esm(() => {
     description: `Retrieve a dataset
 
 Retrieves a specific dataset by its unique identifier`,
-    args: args13,
-    tool: async (client, args14, ctx) => {
-      const [result, apiCall] = await datasetsRetrieve(client, args14.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args14,
+    tool: async (client, args15, ctx) => {
+      const [result, apiCall] = await datasetsRetrieve(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -64982,9 +65543,9 @@ Retrieves a specific dataset by its unique identifier`,
 
 // src/funcs/datasetsRetrieveDatapoint.ts
 function datasetsRetrieveDatapoint(client, request, options) {
-  return new APIPromise($do14(client, request, options));
+  return new APIPromise($do15(client, request, options));
 }
-async function $do14(client, request, options) {
+async function $do15(client, request, options) {
   const parsed = safeParse(request, (value) => RetrieveDatapointRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -65064,12 +65625,12 @@ var init_datasetsRetrieveDatapoint = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsRetrieveDatapoint.ts
-var args14, tool$datasetsRetrieveDatapoint;
+var args15, tool$datasetsRetrieveDatapoint;
 var init_datasetsRetrieveDatapoint2 = __esm(() => {
   init_datasetsRetrieveDatapoint();
   init_operations();
   init_tools();
-  args14 = {
+  args15 = {
     request: RetrieveDatapointRequest$inboundSchema
   };
   tool$datasetsRetrieveDatapoint = {
@@ -65077,9 +65638,9 @@ var init_datasetsRetrieveDatapoint2 = __esm(() => {
     description: `Retrieve a datapoint
 
 Retrieves a datapoint object`,
-    args: args14,
-    tool: async (client, args15, ctx) => {
-      const [result, apiCall] = await datasetsRetrieveDatapoint(client, args15.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args15,
+    tool: async (client, args16, ctx) => {
+      const [result, apiCall] = await datasetsRetrieveDatapoint(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -65094,9 +65655,9 @@ Retrieves a datapoint object`,
 
 // src/funcs/datasetsUpdate.ts
 function datasetsUpdate(client, request, options) {
-  return new APIPromise($do15(client, request, options));
+  return new APIPromise($do16(client, request, options));
 }
-async function $do15(client, request, options) {
+async function $do16(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateDatasetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -65173,12 +65734,12 @@ var init_datasetsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsUpdate.ts
-var args15, tool$datasetsUpdate;
+var args16, tool$datasetsUpdate;
 var init_datasetsUpdate2 = __esm(() => {
   init_datasetsUpdate();
   init_operations();
   init_tools();
-  args15 = {
+  args16 = {
     request: UpdateDatasetRequest$inboundSchema
   };
   tool$datasetsUpdate = {
@@ -65186,9 +65747,9 @@ var init_datasetsUpdate2 = __esm(() => {
     description: `Update a dataset
 
 Update a dataset`,
-    args: args15,
-    tool: async (client, args16, ctx) => {
-      const [result, apiCall] = await datasetsUpdate(client, args16.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args16,
+    tool: async (client, args17, ctx) => {
+      const [result, apiCall] = await datasetsUpdate(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -65203,9 +65764,9 @@ Update a dataset`,
 
 // src/funcs/datasetsUpdateDatapoint.ts
 function datasetsUpdateDatapoint(client, request, options) {
-  return new APIPromise($do16(client, request, options));
+  return new APIPromise($do17(client, request, options));
 }
-async function $do16(client, request, options) {
+async function $do17(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateDatapointRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -65286,20 +65847,20 @@ var init_datasetsUpdateDatapoint = __esm(() => {
 });
 
 // src/mcp-server/tools/datasetsUpdateDatapoint.ts
-var args16, tool$datasetsUpdateDatapoint;
+var args17, tool$datasetsUpdateDatapoint;
 var init_datasetsUpdateDatapoint2 = __esm(() => {
   init_datasetsUpdateDatapoint();
   init_operations();
   init_tools();
-  args16 = {
+  args17 = {
     request: UpdateDatapointRequest$inboundSchema
   };
   tool$datasetsUpdateDatapoint = {
     name: "datasets-update-datapoint",
     description: `Update a datapoint`,
-    args: args16,
-    tool: async (client, args17, ctx) => {
-      const [result, apiCall] = await datasetsUpdateDatapoint(client, args17.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args17,
+    tool: async (client, args18, ctx) => {
+      const [result, apiCall] = await datasetsUpdateDatapoint(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -65314,9 +65875,9 @@ var init_datasetsUpdateDatapoint2 = __esm(() => {
 
 // src/funcs/deploymentsGetConfig.ts
 function deploymentsGetConfig(client, request, options) {
-  return new APIPromise($do17(client, request, options));
+  return new APIPromise($do18(client, request, options));
 }
-async function $do17(client, request, options) {
+async function $do18(client, request, options) {
   const parsed = safeParse(request, (value) => DeploymentGetConfigRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -65383,12 +65944,12 @@ var init_deploymentsGetConfig = __esm(() => {
 });
 
 // src/mcp-server/tools/deploymentsGetConfig.ts
-var args17, tool$deploymentsGetConfig;
+var args18, tool$deploymentsGetConfig;
 var init_deploymentsGetConfig2 = __esm(() => {
   init_deploymentsGetConfig();
   init_operations();
   init_tools();
-  args17 = {
+  args18 = {
     request: DeploymentGetConfigRequestBody$inboundSchema
   };
   tool$deploymentsGetConfig = {
@@ -65396,9 +65957,9 @@ var init_deploymentsGetConfig2 = __esm(() => {
     description: `Get config
 
 Retrieve the deployment configuration`,
-    args: args17,
-    tool: async (client, args18, ctx) => {
-      const [result, apiCall] = await deploymentsGetConfig(client, args18.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args18,
+    tool: async (client, args19, ctx) => {
+      const [result, apiCall] = await deploymentsGetConfig(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -67193,9 +67754,9 @@ var init_components = __esm(() => {
 
 // src/funcs/deploymentsInvoke.ts
 function deploymentsInvoke(client, request, options) {
-  return new APIPromise($do18(client, request, options));
+  return new APIPromise($do19(client, request, options));
 }
-async function $do18(client, request, options) {
+async function $do19(client, request, options) {
   const parsed = safeParse(request, (value) => Deployments$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -67271,12 +67832,12 @@ var init_deploymentsInvoke = __esm(() => {
 });
 
 // src/mcp-server/tools/deploymentsInvoke.ts
-var args18, tool$deploymentsInvoke;
+var args19, tool$deploymentsInvoke;
 var init_deploymentsInvoke2 = __esm(() => {
   init_deploymentsInvoke();
   init_components();
   init_tools();
-  args18 = {
+  args19 = {
     request: Deployments$inboundSchema
   };
   tool$deploymentsInvoke = {
@@ -67284,9 +67845,9 @@ var init_deploymentsInvoke2 = __esm(() => {
     description: `Invoke
 
 Invoke a deployment with a given payload`,
-    args: args18,
-    tool: async (client, args19, ctx) => {
-      const [result, apiCall] = await deploymentsInvoke(client, args19.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args19,
+    tool: async (client, args20, ctx) => {
+      const [result, apiCall] = await deploymentsInvoke(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -67301,9 +67862,9 @@ Invoke a deployment with a given payload`,
 
 // src/funcs/deploymentsList.ts
 function deploymentsList(client, request, options) {
-  return new APIPromise($do19(client, request, options));
+  return new APIPromise($do20(client, request, options));
 }
-async function $do19(client, request, options) {
+async function $do20(client, request, options) {
   const parsed = safeParse(request, (value) => DeploymentsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -67379,12 +67940,12 @@ var init_deploymentsList = __esm(() => {
 });
 
 // src/mcp-server/tools/deploymentsList.ts
-var args19, tool$deploymentsList;
+var args20, tool$deploymentsList;
 var init_deploymentsList2 = __esm(() => {
   init_deploymentsList();
   init_operations();
   init_tools();
-  args19 = {
+  args20 = {
     request: DeploymentsRequest$inboundSchema.optional()
   };
   tool$deploymentsList = {
@@ -67392,9 +67953,9 @@ var init_deploymentsList2 = __esm(() => {
     description: `List all deployments
 
 Returns a list of your deployments. The deployments are returned sorted by creation date, with the most recent deployments appearing first.`,
-    args: args19,
-    tool: async (client, args20, ctx) => {
-      const [result, apiCall] = await deploymentsList(client, args20.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args20,
+    tool: async (client, args21, ctx) => {
+      const [result, apiCall] = await deploymentsList(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -67409,9 +67970,9 @@ Returns a list of your deployments. The deployments are returned sorted by creat
 
 // src/funcs/deploymentsMetricsCreate.ts
 function deploymentsMetricsCreate(client, request, options) {
-  return new APIPromise($do20(client, request, options));
+  return new APIPromise($do21(client, request, options));
 }
-async function $do20(client, request, options) {
+async function $do21(client, request, options) {
   const parsed = safeParse(request, (value) => DeploymentCreateMetricRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -67484,12 +68045,12 @@ var init_deploymentsMetricsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/deploymentsMetricsCreate.ts
-var args20, tool$deploymentsMetricsCreate;
+var args21, tool$deploymentsMetricsCreate;
 var init_deploymentsMetricsCreate2 = __esm(() => {
   init_deploymentsMetricsCreate();
   init_operations();
   init_tools();
-  args20 = {
+  args21 = {
     request: DeploymentCreateMetricRequest$inboundSchema
   };
   tool$deploymentsMetricsCreate = {
@@ -67497,9 +68058,9 @@ var init_deploymentsMetricsCreate2 = __esm(() => {
     description: `Add metrics
 
 Add metrics to a deployment`,
-    args: args20,
-    tool: async (client, args21, ctx) => {
-      const [result, apiCall] = await deploymentsMetricsCreate(client, args21.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args21,
+    tool: async (client, args22, ctx) => {
+      const [result, apiCall] = await deploymentsMetricsCreate(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -67546,7 +68107,7 @@ function* chunks(remainder) {
     yield { chunk, remainder };
   }
 }
-function parseChunk(chunk, parse) {
+function parseChunk(chunk, parse2) {
   const text = new TextDecoder().decode(chunk);
   const lines = text.split(/\r\n|\r|\n/);
   const dataLines = [];
@@ -67576,12 +68137,12 @@ function parseChunk(chunk, parse) {
   if (dataLines.length)
     ret.data = dataLines.join(`
 `);
-  return parse(ret);
+  return parse2(ret);
 }
 var EventStream;
 var init_event_streams = __esm(() => {
   EventStream = class EventStream extends ReadableStream {
-    constructor(stream, parse) {
+    constructor(stream, parse2) {
       const reader = stream.getReader();
       let buffer = new Uint8Array;
       super({
@@ -67593,7 +68154,7 @@ var init_event_streams = __esm(() => {
             buffer = concatBuffer(buffer, r.value);
             for (const { chunk, remainder } of chunks(buffer)) {
               buffer = remainder;
-              const item = parseChunk(chunk, parse);
+              const item = parseChunk(chunk, parse2);
               if (item?.value)
                 controller.enqueue(item.value);
               if (item?.done) {
@@ -67643,9 +68204,9 @@ var init_event_streams = __esm(() => {
 
 // src/funcs/deploymentsStream.ts
 function deploymentsStream(client, request, options) {
-  return new APIPromise($do21(client, request, options));
+  return new APIPromise($do22(client, request, options));
 }
-async function $do21(client, request, options) {
+async function $do22(client, request, options) {
   const parsed = safeParse(request, (value) => DeploymentStreamRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -67730,12 +68291,12 @@ var init_deploymentsStream = __esm(() => {
 });
 
 // src/mcp-server/tools/deploymentsStream.ts
-var args21, tool$deploymentsStream;
+var args22, tool$deploymentsStream;
 var init_deploymentsStream2 = __esm(() => {
   init_deploymentsStream();
   init_operations();
   init_tools();
-  args21 = {
+  args22 = {
     request: DeploymentStreamRequestBody$inboundSchema
   };
   tool$deploymentsStream = {
@@ -67743,9 +68304,9 @@ var init_deploymentsStream2 = __esm(() => {
     description: `Stream
 
 Stream deployment generation. Only supported for completions and chat completions.`,
-    args: args21,
-    tool: async (client, args22, ctx) => {
-      const [result, apiCall] = await deploymentsStream(client, args22.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args22,
+    tool: async (client, args23, ctx) => {
+      const [result, apiCall] = await deploymentsStream(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -67760,9 +68321,9 @@ Stream deployment generation. Only supported for completions and chat completion
 
 // src/funcs/evalsAgeAppropriate.ts
 function evalsAgeAppropriate(client, request, options) {
-  return new APIPromise($do22(client, request, options));
+  return new APIPromise($do23(client, request, options));
 }
-async function $do22(client, request, options) {
+async function $do23(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsAgeAppropriateRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -67833,20 +68394,20 @@ var init_evalsAgeAppropriate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsAgeAppropriate.ts
-var args22, tool$evalsAgeAppropriate;
+var args23, tool$evalsAgeAppropriate;
 var init_evalsAgeAppropriate2 = __esm(() => {
   init_evalsAgeAppropriate();
   init_operations();
   init_tools();
-  args22 = {
+  args23 = {
     request: EvalsAgeAppropriateRequestBody$inboundSchema.optional()
   };
   tool$evalsAgeAppropriate = {
     name: "evals-age-appropriate",
     description: `Run Age Appropriate Evaluator`,
-    args: args22,
-    tool: async (client, args23, ctx) => {
-      const [result, apiCall] = await evalsAgeAppropriate(client, args23.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args23,
+    tool: async (client, args24, ctx) => {
+      const [result, apiCall] = await evalsAgeAppropriate(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -67861,9 +68422,9 @@ var init_evalsAgeAppropriate2 = __esm(() => {
 
 // src/funcs/evalsAll.ts
 function evalsAll(client, request, options) {
-  return new APIPromise($do23(client, request, options));
+  return new APIPromise($do24(client, request, options));
 }
-async function $do23(client, request, options) {
+async function $do24(client, request, options) {
   const parsed = safeParse(request, (value) => GetEvalsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -67939,20 +68500,20 @@ var init_evalsAll = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsAll.ts
-var args23, tool$evalsAll;
+var args24, tool$evalsAll;
 var init_evalsAll2 = __esm(() => {
   init_evalsAll();
   init_operations();
   init_tools();
-  args23 = {
+  args24 = {
     request: GetEvalsRequest$inboundSchema.optional()
   };
   tool$evalsAll = {
     name: "evals-all",
     description: `Get all Evaluators`,
-    args: args23,
-    tool: async (client, args24, ctx) => {
-      const [result, apiCall] = await evalsAll(client, args24.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args24,
+    tool: async (client, args25, ctx) => {
+      const [result, apiCall] = await evalsAll(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -67967,9 +68528,9 @@ var init_evalsAll2 = __esm(() => {
 
 // src/funcs/evalsBertScore.ts
 function evalsBertScore(client, request, options) {
-  return new APIPromise($do24(client, request, options));
+  return new APIPromise($do25(client, request, options));
 }
-async function $do24(client, request, options) {
+async function $do25(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsBertScoreRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68040,20 +68601,20 @@ var init_evalsBertScore = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsBertScore.ts
-var args24, tool$evalsBertScore;
+var args25, tool$evalsBertScore;
 var init_evalsBertScore2 = __esm(() => {
   init_evalsBertScore();
   init_operations();
   init_tools();
-  args24 = {
+  args25 = {
     request: EvalsBertScoreRequestBody$inboundSchema.optional()
   };
   tool$evalsBertScore = {
     name: "evals-bert-score",
     description: `Run BertScore Evaluator`,
-    args: args24,
-    tool: async (client, args25, ctx) => {
-      const [result, apiCall] = await evalsBertScore(client, args25.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args25,
+    tool: async (client, args26, ctx) => {
+      const [result, apiCall] = await evalsBertScore(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68068,9 +68629,9 @@ var init_evalsBertScore2 = __esm(() => {
 
 // src/funcs/evalsBleuScore.ts
 function evalsBleuScore(client, request, options) {
-  return new APIPromise($do25(client, request, options));
+  return new APIPromise($do26(client, request, options));
 }
-async function $do25(client, request, options) {
+async function $do26(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsBleuScoreRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68141,20 +68702,20 @@ var init_evalsBleuScore = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsBleuScore.ts
-var args25, tool$evalsBleuScore;
+var args26, tool$evalsBleuScore;
 var init_evalsBleuScore2 = __esm(() => {
   init_evalsBleuScore();
   init_operations();
   init_tools();
-  args25 = {
+  args26 = {
     request: EvalsBleuScoreRequestBody$inboundSchema.optional()
   };
   tool$evalsBleuScore = {
     name: "evals-bleu-score",
     description: `Run BLEU Score Evaluator`,
-    args: args25,
-    tool: async (client, args26, ctx) => {
-      const [result, apiCall] = await evalsBleuScore(client, args26.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args26,
+    tool: async (client, args27, ctx) => {
+      const [result, apiCall] = await evalsBleuScore(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68169,9 +68730,9 @@ var init_evalsBleuScore2 = __esm(() => {
 
 // src/funcs/evalsBotDetection.ts
 function evalsBotDetection(client, request, options) {
-  return new APIPromise($do26(client, request, options));
+  return new APIPromise($do27(client, request, options));
 }
-async function $do26(client, request, options) {
+async function $do27(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsBotDetectionRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68242,20 +68803,20 @@ var init_evalsBotDetection = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsBotDetection.ts
-var args26, tool$evalsBotDetection;
+var args27, tool$evalsBotDetection;
 var init_evalsBotDetection2 = __esm(() => {
   init_evalsBotDetection();
   init_operations();
   init_tools();
-  args26 = {
+  args27 = {
     request: EvalsBotDetectionRequestBody$inboundSchema.optional()
   };
   tool$evalsBotDetection = {
     name: "evals-bot-detection",
     description: `Run Bot Detection Evaluator`,
-    args: args26,
-    tool: async (client, args27, ctx) => {
-      const [result, apiCall] = await evalsBotDetection(client, args27.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args27,
+    tool: async (client, args28, ctx) => {
+      const [result, apiCall] = await evalsBotDetection(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68270,9 +68831,9 @@ var init_evalsBotDetection2 = __esm(() => {
 
 // src/funcs/evalsContains.ts
 function evalsContains(client, request, options) {
-  return new APIPromise($do27(client, request, options));
+  return new APIPromise($do28(client, request, options));
 }
-async function $do27(client, request, options) {
+async function $do28(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsContainsRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68343,20 +68904,20 @@ var init_evalsContains = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsContains.ts
-var args27, tool$evalsContains;
+var args28, tool$evalsContains;
 var init_evalsContains2 = __esm(() => {
   init_evalsContains();
   init_operations();
   init_tools();
-  args27 = {
+  args28 = {
     request: EvalsContainsRequestBody$inboundSchema.optional()
   };
   tool$evalsContains = {
     name: "evals-contains",
     description: `Run Contains Evaluator`,
-    args: args27,
-    tool: async (client, args28, ctx) => {
-      const [result, apiCall] = await evalsContains(client, args28.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args28,
+    tool: async (client, args29, ctx) => {
+      const [result, apiCall] = await evalsContains(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68371,9 +68932,9 @@ var init_evalsContains2 = __esm(() => {
 
 // src/funcs/evalsContainsAll.ts
 function evalsContainsAll(client, request, options) {
-  return new APIPromise($do28(client, request, options));
+  return new APIPromise($do29(client, request, options));
 }
-async function $do28(client, request, options) {
+async function $do29(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsContainsAllRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68444,20 +69005,20 @@ var init_evalsContainsAll = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsContainsAll.ts
-var args28, tool$evalsContainsAll;
+var args29, tool$evalsContainsAll;
 var init_evalsContainsAll2 = __esm(() => {
   init_evalsContainsAll();
   init_operations();
   init_tools();
-  args28 = {
+  args29 = {
     request: EvalsContainsAllRequestBody$inboundSchema.optional()
   };
   tool$evalsContainsAll = {
     name: "evals-contains-all",
     description: `Run Contains All Evaluator`,
-    args: args28,
-    tool: async (client, args29, ctx) => {
-      const [result, apiCall] = await evalsContainsAll(client, args29.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args29,
+    tool: async (client, args30, ctx) => {
+      const [result, apiCall] = await evalsContainsAll(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68472,9 +69033,9 @@ var init_evalsContainsAll2 = __esm(() => {
 
 // src/funcs/evalsContainsAny.ts
 function evalsContainsAny(client, request, options) {
-  return new APIPromise($do29(client, request, options));
+  return new APIPromise($do30(client, request, options));
 }
-async function $do29(client, request, options) {
+async function $do30(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsContainsAnyRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68545,20 +69106,20 @@ var init_evalsContainsAny = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsContainsAny.ts
-var args29, tool$evalsContainsAny;
+var args30, tool$evalsContainsAny;
 var init_evalsContainsAny2 = __esm(() => {
   init_evalsContainsAny();
   init_operations();
   init_tools();
-  args29 = {
+  args30 = {
     request: EvalsContainsAnyRequestBody$inboundSchema.optional()
   };
   tool$evalsContainsAny = {
     name: "evals-contains-any",
     description: `Run Contains Any Evaluator`,
-    args: args29,
-    tool: async (client, args30, ctx) => {
-      const [result, apiCall] = await evalsContainsAny(client, args30.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args30,
+    tool: async (client, args31, ctx) => {
+      const [result, apiCall] = await evalsContainsAny(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68573,9 +69134,9 @@ var init_evalsContainsAny2 = __esm(() => {
 
 // src/funcs/evalsContainsEmail.ts
 function evalsContainsEmail(client, request, options) {
-  return new APIPromise($do30(client, request, options));
+  return new APIPromise($do31(client, request, options));
 }
-async function $do30(client, request, options) {
+async function $do31(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsContainsEmailRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68646,20 +69207,20 @@ var init_evalsContainsEmail = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsContainsEmail.ts
-var args30, tool$evalsContainsEmail;
+var args31, tool$evalsContainsEmail;
 var init_evalsContainsEmail2 = __esm(() => {
   init_evalsContainsEmail();
   init_operations();
   init_tools();
-  args30 = {
+  args31 = {
     request: EvalsContainsEmailRequestBody$inboundSchema.optional()
   };
   tool$evalsContainsEmail = {
     name: "evals-contains-email",
     description: `Run Contains Email Evaluator`,
-    args: args30,
-    tool: async (client, args31, ctx) => {
-      const [result, apiCall] = await evalsContainsEmail(client, args31.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args31,
+    tool: async (client, args32, ctx) => {
+      const [result, apiCall] = await evalsContainsEmail(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68674,9 +69235,9 @@ var init_evalsContainsEmail2 = __esm(() => {
 
 // src/funcs/evalsContainsNone.ts
 function evalsContainsNone(client, request, options) {
-  return new APIPromise($do31(client, request, options));
+  return new APIPromise($do32(client, request, options));
 }
-async function $do31(client, request, options) {
+async function $do32(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsContainsNoneRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68747,20 +69308,20 @@ var init_evalsContainsNone = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsContainsNone.ts
-var args31, tool$evalsContainsNone;
+var args32, tool$evalsContainsNone;
 var init_evalsContainsNone2 = __esm(() => {
   init_evalsContainsNone();
   init_operations();
   init_tools();
-  args31 = {
+  args32 = {
     request: EvalsContainsNoneRequestBody$inboundSchema.optional()
   };
   tool$evalsContainsNone = {
     name: "evals-contains-none",
     description: `Run Contains None Evaluator`,
-    args: args31,
-    tool: async (client, args32, ctx) => {
-      const [result, apiCall] = await evalsContainsNone(client, args32.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args32,
+    tool: async (client, args33, ctx) => {
+      const [result, apiCall] = await evalsContainsNone(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68775,9 +69336,9 @@ var init_evalsContainsNone2 = __esm(() => {
 
 // src/funcs/evalsContainsUrl.ts
 function evalsContainsUrl(client, request, options) {
-  return new APIPromise($do32(client, request, options));
+  return new APIPromise($do33(client, request, options));
 }
-async function $do32(client, request, options) {
+async function $do33(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsContainsUrlRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68848,20 +69409,20 @@ var init_evalsContainsUrl = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsContainsUrl.ts
-var args32, tool$evalsContainsUrl;
+var args33, tool$evalsContainsUrl;
 var init_evalsContainsUrl2 = __esm(() => {
   init_evalsContainsUrl();
   init_operations();
   init_tools();
-  args32 = {
+  args33 = {
     request: EvalsContainsUrlRequestBody$inboundSchema.optional()
   };
   tool$evalsContainsUrl = {
     name: "evals-contains-url",
     description: `Run Contains URL Evaluator`,
-    args: args32,
-    tool: async (client, args33, ctx) => {
-      const [result, apiCall] = await evalsContainsUrl(client, args33.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args33,
+    tool: async (client, args34, ctx) => {
+      const [result, apiCall] = await evalsContainsUrl(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68876,9 +69437,9 @@ var init_evalsContainsUrl2 = __esm(() => {
 
 // src/funcs/evalsContainsValidLink.ts
 function evalsContainsValidLink(client, request, options) {
-  return new APIPromise($do33(client, request, options));
+  return new APIPromise($do34(client, request, options));
 }
-async function $do33(client, request, options) {
+async function $do34(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsContainsValidLinkRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -68949,20 +69510,20 @@ var init_evalsContainsValidLink = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsContainsValidLink.ts
-var args33, tool$evalsContainsValidLink;
+var args34, tool$evalsContainsValidLink;
 var init_evalsContainsValidLink2 = __esm(() => {
   init_evalsContainsValidLink();
   init_operations();
   init_tools();
-  args33 = {
+  args34 = {
     request: EvalsContainsValidLinkRequestBody$inboundSchema.optional()
   };
   tool$evalsContainsValidLink = {
     name: "evals-contains-valid-link",
     description: `Run Contains Valid Link Evaluator`,
-    args: args33,
-    tool: async (client, args34, ctx) => {
-      const [result, apiCall] = await evalsContainsValidLink(client, args34.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args34,
+    tool: async (client, args35, ctx) => {
+      const [result, apiCall] = await evalsContainsValidLink(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -68977,9 +69538,9 @@ var init_evalsContainsValidLink2 = __esm(() => {
 
 // src/funcs/evalsCreate.ts
 function evalsCreate(client, request, options) {
-  return new APIPromise($do34(client, request, options));
+  return new APIPromise($do35(client, request, options));
 }
-async function $do34(client, request, options) {
+async function $do35(client, request, options) {
   const parsed = safeParse(request, (value) => CreateEvalRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69050,20 +69611,20 @@ var init_evalsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsCreate.ts
-var args34, tool$evalsCreate;
+var args35, tool$evalsCreate;
 var init_evalsCreate2 = __esm(() => {
   init_evalsCreate();
   init_operations();
   init_tools();
-  args34 = {
+  args35 = {
     request: CreateEvalRequestBody$inboundSchema.optional()
   };
   tool$evalsCreate = {
     name: "evals-create",
     description: `Create an Evaluator`,
-    args: args34,
-    tool: async (client, args35, ctx) => {
-      const [result, apiCall] = await evalsCreate(client, args35.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args35,
+    tool: async (client, args36, ctx) => {
+      const [result, apiCall] = await evalsCreate(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69078,9 +69639,9 @@ var init_evalsCreate2 = __esm(() => {
 
 // src/funcs/evalsDelete.ts
 function evalsDelete(client, request, options) {
-  return new APIPromise($do35(client, request, options));
+  return new APIPromise($do36(client, request, options));
 }
-async function $do35(client, request, options) {
+async function $do36(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteEvalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69157,20 +69718,20 @@ var init_evalsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsDelete.ts
-var args35, tool$evalsDelete;
+var args36, tool$evalsDelete;
 var init_evalsDelete2 = __esm(() => {
   init_evalsDelete();
   init_operations();
   init_tools();
-  args35 = {
+  args36 = {
     request: DeleteEvalRequest$inboundSchema
   };
   tool$evalsDelete = {
     name: "evals-delete",
     description: `Delete an Evaluator`,
-    args: args35,
-    tool: async (client, args36, ctx) => {
-      const [result, apiCall] = await evalsDelete(client, args36.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args36,
+    tool: async (client, args37, ctx) => {
+      const [result, apiCall] = await evalsDelete(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69184,9 +69745,9 @@ var init_evalsDelete2 = __esm(() => {
 
 // src/funcs/evalsEndsWith.ts
 function evalsEndsWith(client, request, options) {
-  return new APIPromise($do36(client, request, options));
+  return new APIPromise($do37(client, request, options));
 }
-async function $do36(client, request, options) {
+async function $do37(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsEndsWithRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69257,20 +69818,20 @@ var init_evalsEndsWith = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsEndsWith.ts
-var args36, tool$evalsEndsWith;
+var args37, tool$evalsEndsWith;
 var init_evalsEndsWith2 = __esm(() => {
   init_evalsEndsWith();
   init_operations();
   init_tools();
-  args36 = {
+  args37 = {
     request: EvalsEndsWithRequestBody$inboundSchema.optional()
   };
   tool$evalsEndsWith = {
     name: "evals-ends-with",
     description: `Run Ends With Evaluator`,
-    args: args36,
-    tool: async (client, args37, ctx) => {
-      const [result, apiCall] = await evalsEndsWith(client, args37.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args37,
+    tool: async (client, args38, ctx) => {
+      const [result, apiCall] = await evalsEndsWith(client, args38.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69285,9 +69846,9 @@ var init_evalsEndsWith2 = __esm(() => {
 
 // src/funcs/evalsExactMatch.ts
 function evalsExactMatch(client, request, options) {
-  return new APIPromise($do37(client, request, options));
+  return new APIPromise($do38(client, request, options));
 }
-async function $do37(client, request, options) {
+async function $do38(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsExactMatchRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69358,20 +69919,20 @@ var init_evalsExactMatch = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsExactMatch.ts
-var args37, tool$evalsExactMatch;
+var args38, tool$evalsExactMatch;
 var init_evalsExactMatch2 = __esm(() => {
   init_evalsExactMatch();
   init_operations();
   init_tools();
-  args37 = {
+  args38 = {
     request: EvalsExactMatchRequestBody$inboundSchema.optional()
   };
   tool$evalsExactMatch = {
     name: "evals-exact-match",
     description: `Run Exact Match Evaluator`,
-    args: args37,
-    tool: async (client, args38, ctx) => {
-      const [result, apiCall] = await evalsExactMatch(client, args38.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args38,
+    tool: async (client, args39, ctx) => {
+      const [result, apiCall] = await evalsExactMatch(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69386,9 +69947,9 @@ var init_evalsExactMatch2 = __esm(() => {
 
 // src/funcs/evalsFactCheckingKnowledgeBase.ts
 function evalsFactCheckingKnowledgeBase(client, request, options) {
-  return new APIPromise($do38(client, request, options));
+  return new APIPromise($do39(client, request, options));
 }
-async function $do38(client, request, options) {
+async function $do39(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsFactCheckingKnowledgeBaseRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69459,20 +70020,20 @@ var init_evalsFactCheckingKnowledgeBase = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsFactCheckingKnowledgeBase.ts
-var args38, tool$evalsFactCheckingKnowledgeBase;
+var args39, tool$evalsFactCheckingKnowledgeBase;
 var init_evalsFactCheckingKnowledgeBase2 = __esm(() => {
   init_evalsFactCheckingKnowledgeBase();
   init_operations();
   init_tools();
-  args38 = {
+  args39 = {
     request: EvalsFactCheckingKnowledgeBaseRequestBody$inboundSchema.optional()
   };
   tool$evalsFactCheckingKnowledgeBase = {
     name: "evals-fact-checking-knowledge-base",
     description: `Run Fact Checking Knowledge Base Evaluator`,
-    args: args38,
-    tool: async (client, args39, ctx) => {
-      const [result, apiCall] = await evalsFactCheckingKnowledgeBase(client, args39.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args39,
+    tool: async (client, args40, ctx) => {
+      const [result, apiCall] = await evalsFactCheckingKnowledgeBase(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69487,9 +70048,9 @@ var init_evalsFactCheckingKnowledgeBase2 = __esm(() => {
 
 // src/funcs/evalsGrammar.ts
 function evalsGrammar(client, request, options) {
-  return new APIPromise($do39(client, request, options));
+  return new APIPromise($do40(client, request, options));
 }
-async function $do39(client, request, options) {
+async function $do40(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsGrammarRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69560,20 +70121,20 @@ var init_evalsGrammar = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsGrammar.ts
-var args39, tool$evalsGrammar;
+var args40, tool$evalsGrammar;
 var init_evalsGrammar2 = __esm(() => {
   init_evalsGrammar();
   init_operations();
   init_tools();
-  args39 = {
+  args40 = {
     request: EvalsGrammarRequestBody$inboundSchema.optional()
   };
   tool$evalsGrammar = {
     name: "evals-grammar",
     description: `Run Grammar Evaluator`,
-    args: args39,
-    tool: async (client, args40, ctx) => {
-      const [result, apiCall] = await evalsGrammar(client, args40.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args40,
+    tool: async (client, args41, ctx) => {
+      const [result, apiCall] = await evalsGrammar(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69588,9 +70149,9 @@ var init_evalsGrammar2 = __esm(() => {
 
 // src/funcs/evalsInvoke.ts
 function evalsInvoke(client, request, options) {
-  return new APIPromise($do40(client, request, options));
+  return new APIPromise($do41(client, request, options));
 }
-async function $do40(client, request, options) {
+async function $do41(client, request, options) {
   const parsed = safeParse(request, (value) => InvokeEvalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69667,20 +70228,20 @@ var init_evalsInvoke = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsInvoke.ts
-var args40, tool$evalsInvoke;
+var args41, tool$evalsInvoke;
 var init_evalsInvoke2 = __esm(() => {
   init_evalsInvoke();
   init_operations();
   init_tools();
-  args40 = {
+  args41 = {
     request: InvokeEvalRequest$inboundSchema
   };
   tool$evalsInvoke = {
     name: "evals-invoke",
     description: `Invoke a Custom Evaluator`,
-    args: args40,
-    tool: async (client, args41, ctx) => {
-      const [result, apiCall] = await evalsInvoke(client, args41.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args41,
+    tool: async (client, args42, ctx) => {
+      const [result, apiCall] = await evalsInvoke(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69695,9 +70256,9 @@ var init_evalsInvoke2 = __esm(() => {
 
 // src/funcs/evalsLengthBetween.ts
 function evalsLengthBetween(client, request, options) {
-  return new APIPromise($do41(client, request, options));
+  return new APIPromise($do42(client, request, options));
 }
-async function $do41(client, request, options) {
+async function $do42(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsLengthBetweenRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69768,20 +70329,20 @@ var init_evalsLengthBetween = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsLengthBetween.ts
-var args41, tool$evalsLengthBetween;
+var args42, tool$evalsLengthBetween;
 var init_evalsLengthBetween2 = __esm(() => {
   init_evalsLengthBetween();
   init_operations();
   init_tools();
-  args41 = {
+  args42 = {
     request: EvalsLengthBetweenRequestBody$inboundSchema.optional()
   };
   tool$evalsLengthBetween = {
     name: "evals-length-between",
     description: `Run Length Between Evaluator`,
-    args: args41,
-    tool: async (client, args42, ctx) => {
-      const [result, apiCall] = await evalsLengthBetween(client, args42.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args42,
+    tool: async (client, args43, ctx) => {
+      const [result, apiCall] = await evalsLengthBetween(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69796,9 +70357,9 @@ var init_evalsLengthBetween2 = __esm(() => {
 
 // src/funcs/evalsLengthGreaterThan.ts
 function evalsLengthGreaterThan(client, request, options) {
-  return new APIPromise($do42(client, request, options));
+  return new APIPromise($do43(client, request, options));
 }
-async function $do42(client, request, options) {
+async function $do43(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsLengthGreaterThanRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69869,20 +70430,20 @@ var init_evalsLengthGreaterThan = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsLengthGreaterThan.ts
-var args42, tool$evalsLengthGreaterThan;
+var args43, tool$evalsLengthGreaterThan;
 var init_evalsLengthGreaterThan2 = __esm(() => {
   init_evalsLengthGreaterThan();
   init_operations();
   init_tools();
-  args42 = {
+  args43 = {
     request: EvalsLengthGreaterThanRequestBody$inboundSchema.optional()
   };
   tool$evalsLengthGreaterThan = {
     name: "evals-length-greater-than",
     description: `Run Length Greater Than Evaluator`,
-    args: args42,
-    tool: async (client, args43, ctx) => {
-      const [result, apiCall] = await evalsLengthGreaterThan(client, args43.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args43,
+    tool: async (client, args44, ctx) => {
+      const [result, apiCall] = await evalsLengthGreaterThan(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69897,9 +70458,9 @@ var init_evalsLengthGreaterThan2 = __esm(() => {
 
 // src/funcs/evalsLengthLessThan.ts
 function evalsLengthLessThan(client, request, options) {
-  return new APIPromise($do43(client, request, options));
+  return new APIPromise($do44(client, request, options));
 }
-async function $do43(client, request, options) {
+async function $do44(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsLengthLessThanRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -69970,20 +70531,20 @@ var init_evalsLengthLessThan = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsLengthLessThan.ts
-var args43, tool$evalsLengthLessThan;
+var args44, tool$evalsLengthLessThan;
 var init_evalsLengthLessThan2 = __esm(() => {
   init_evalsLengthLessThan();
   init_operations();
   init_tools();
-  args43 = {
+  args44 = {
     request: EvalsLengthLessThanRequestBody$inboundSchema.optional()
   };
   tool$evalsLengthLessThan = {
     name: "evals-length-less-than",
     description: `Run Length Less Than Evaluator`,
-    args: args43,
-    tool: async (client, args44, ctx) => {
-      const [result, apiCall] = await evalsLengthLessThan(client, args44.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args44,
+    tool: async (client, args45, ctx) => {
+      const [result, apiCall] = await evalsLengthLessThan(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -69998,9 +70559,9 @@ var init_evalsLengthLessThan2 = __esm(() => {
 
 // src/funcs/evalsLocalization.ts
 function evalsLocalization(client, request, options) {
-  return new APIPromise($do44(client, request, options));
+  return new APIPromise($do45(client, request, options));
 }
-async function $do44(client, request, options) {
+async function $do45(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsLocalizationRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70071,20 +70632,20 @@ var init_evalsLocalization = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsLocalization.ts
-var args44, tool$evalsLocalization;
+var args45, tool$evalsLocalization;
 var init_evalsLocalization2 = __esm(() => {
   init_evalsLocalization();
   init_operations();
   init_tools();
-  args44 = {
+  args45 = {
     request: EvalsLocalizationRequestBody$inboundSchema.optional()
   };
   tool$evalsLocalization = {
     name: "evals-localization",
     description: `Run Localization Evaluator`,
-    args: args44,
-    tool: async (client, args45, ctx) => {
-      const [result, apiCall] = await evalsLocalization(client, args45.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args45,
+    tool: async (client, args46, ctx) => {
+      const [result, apiCall] = await evalsLocalization(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70099,9 +70660,9 @@ var init_evalsLocalization2 = __esm(() => {
 
 // src/funcs/evalsPii.ts
 function evalsPii(client, request, options) {
-  return new APIPromise($do45(client, request, options));
+  return new APIPromise($do46(client, request, options));
 }
-async function $do45(client, request, options) {
+async function $do46(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsPiiRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70172,20 +70733,20 @@ var init_evalsPii = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsPii.ts
-var args45, tool$evalsPii;
+var args46, tool$evalsPii;
 var init_evalsPii2 = __esm(() => {
   init_evalsPii();
   init_operations();
   init_tools();
-  args45 = {
+  args46 = {
     request: EvalsPiiRequestBody$inboundSchema.optional()
   };
   tool$evalsPii = {
     name: "evals-pii",
     description: `Run PII Evaluator`,
-    args: args45,
-    tool: async (client, args46, ctx) => {
-      const [result, apiCall] = await evalsPii(client, args46.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args46,
+    tool: async (client, args47, ctx) => {
+      const [result, apiCall] = await evalsPii(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70200,9 +70761,9 @@ var init_evalsPii2 = __esm(() => {
 
 // src/funcs/evalsRagasCoherence.ts
 function evalsRagasCoherence(client, request, options) {
-  return new APIPromise($do46(client, request, options));
+  return new APIPromise($do47(client, request, options));
 }
-async function $do46(client, request, options) {
+async function $do47(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasCoherenceRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70273,20 +70834,20 @@ var init_evalsRagasCoherence = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasCoherence.ts
-var args46, tool$evalsRagasCoherence;
+var args47, tool$evalsRagasCoherence;
 var init_evalsRagasCoherence2 = __esm(() => {
   init_evalsRagasCoherence();
   init_operations();
   init_tools();
-  args46 = {
+  args47 = {
     request: EvalsRagasCoherenceRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasCoherence = {
     name: "evals-ragas-coherence",
     description: `Run Coherence Evaluator`,
-    args: args46,
-    tool: async (client, args47, ctx) => {
-      const [result, apiCall] = await evalsRagasCoherence(client, args47.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args47,
+    tool: async (client, args48, ctx) => {
+      const [result, apiCall] = await evalsRagasCoherence(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70301,9 +70862,9 @@ var init_evalsRagasCoherence2 = __esm(() => {
 
 // src/funcs/evalsRagasConciseness.ts
 function evalsRagasConciseness(client, request, options) {
-  return new APIPromise($do47(client, request, options));
+  return new APIPromise($do48(client, request, options));
 }
-async function $do47(client, request, options) {
+async function $do48(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasConcisenessRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70374,20 +70935,20 @@ var init_evalsRagasConciseness = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasConciseness.ts
-var args47, tool$evalsRagasConciseness;
+var args48, tool$evalsRagasConciseness;
 var init_evalsRagasConciseness2 = __esm(() => {
   init_evalsRagasConciseness();
   init_operations();
   init_tools();
-  args47 = {
+  args48 = {
     request: EvalsRagasConcisenessRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasConciseness = {
     name: "evals-ragas-conciseness",
     description: `Run Conciseness Evaluator`,
-    args: args47,
-    tool: async (client, args48, ctx) => {
-      const [result, apiCall] = await evalsRagasConciseness(client, args48.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args48,
+    tool: async (client, args49, ctx) => {
+      const [result, apiCall] = await evalsRagasConciseness(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70402,9 +70963,9 @@ var init_evalsRagasConciseness2 = __esm(() => {
 
 // src/funcs/evalsRagasContextEntitiesRecall.ts
 function evalsRagasContextEntitiesRecall(client, request, options) {
-  return new APIPromise($do48(client, request, options));
+  return new APIPromise($do49(client, request, options));
 }
-async function $do48(client, request, options) {
+async function $do49(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasContextEntitiesRecallRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70475,20 +71036,20 @@ var init_evalsRagasContextEntitiesRecall = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasContextEntitiesRecall.ts
-var args48, tool$evalsRagasContextEntitiesRecall;
+var args49, tool$evalsRagasContextEntitiesRecall;
 var init_evalsRagasContextEntitiesRecall2 = __esm(() => {
   init_evalsRagasContextEntitiesRecall();
   init_operations();
   init_tools();
-  args48 = {
+  args49 = {
     request: EvalsRagasContextEntitiesRecallRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasContextEntitiesRecall = {
     name: "evals-ragas-context-entities-recall",
     description: `Run Context Entities Recall Evaluator`,
-    args: args48,
-    tool: async (client, args49, ctx) => {
-      const [result, apiCall] = await evalsRagasContextEntitiesRecall(client, args49.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args49,
+    tool: async (client, args50, ctx) => {
+      const [result, apiCall] = await evalsRagasContextEntitiesRecall(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70503,9 +71064,9 @@ var init_evalsRagasContextEntitiesRecall2 = __esm(() => {
 
 // src/funcs/evalsRagasContextPrecision.ts
 function evalsRagasContextPrecision(client, request, options) {
-  return new APIPromise($do49(client, request, options));
+  return new APIPromise($do50(client, request, options));
 }
-async function $do49(client, request, options) {
+async function $do50(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasContextPrecisionRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70576,20 +71137,20 @@ var init_evalsRagasContextPrecision = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasContextPrecision.ts
-var args49, tool$evalsRagasContextPrecision;
+var args50, tool$evalsRagasContextPrecision;
 var init_evalsRagasContextPrecision2 = __esm(() => {
   init_evalsRagasContextPrecision();
   init_operations();
   init_tools();
-  args49 = {
+  args50 = {
     request: EvalsRagasContextPrecisionRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasContextPrecision = {
     name: "evals-ragas-context-precision",
     description: `Run Context Precision Evaluator`,
-    args: args49,
-    tool: async (client, args50, ctx) => {
-      const [result, apiCall] = await evalsRagasContextPrecision(client, args50.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args50,
+    tool: async (client, args51, ctx) => {
+      const [result, apiCall] = await evalsRagasContextPrecision(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70604,9 +71165,9 @@ var init_evalsRagasContextPrecision2 = __esm(() => {
 
 // src/funcs/evalsRagasContextRecall.ts
 function evalsRagasContextRecall(client, request, options) {
-  return new APIPromise($do50(client, request, options));
+  return new APIPromise($do51(client, request, options));
 }
-async function $do50(client, request, options) {
+async function $do51(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasContextRecallRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70677,20 +71238,20 @@ var init_evalsRagasContextRecall = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasContextRecall.ts
-var args50, tool$evalsRagasContextRecall;
+var args51, tool$evalsRagasContextRecall;
 var init_evalsRagasContextRecall2 = __esm(() => {
   init_evalsRagasContextRecall();
   init_operations();
   init_tools();
-  args50 = {
+  args51 = {
     request: EvalsRagasContextRecallRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasContextRecall = {
     name: "evals-ragas-context-recall",
     description: `Run Context Recall Evaluator`,
-    args: args50,
-    tool: async (client, args51, ctx) => {
-      const [result, apiCall] = await evalsRagasContextRecall(client, args51.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args51,
+    tool: async (client, args52, ctx) => {
+      const [result, apiCall] = await evalsRagasContextRecall(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70705,9 +71266,9 @@ var init_evalsRagasContextRecall2 = __esm(() => {
 
 // src/funcs/evalsRagasCorrectness.ts
 function evalsRagasCorrectness(client, request, options) {
-  return new APIPromise($do51(client, request, options));
+  return new APIPromise($do52(client, request, options));
 }
-async function $do51(client, request, options) {
+async function $do52(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasCorrectnessRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70778,20 +71339,20 @@ var init_evalsRagasCorrectness = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasCorrectness.ts
-var args51, tool$evalsRagasCorrectness;
+var args52, tool$evalsRagasCorrectness;
 var init_evalsRagasCorrectness2 = __esm(() => {
   init_evalsRagasCorrectness();
   init_operations();
   init_tools();
-  args51 = {
+  args52 = {
     request: EvalsRagasCorrectnessRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasCorrectness = {
     name: "evals-ragas-correctness",
     description: `Run Correctness Evaluator`,
-    args: args51,
-    tool: async (client, args52, ctx) => {
-      const [result, apiCall] = await evalsRagasCorrectness(client, args52.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args52,
+    tool: async (client, args53, ctx) => {
+      const [result, apiCall] = await evalsRagasCorrectness(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70806,9 +71367,9 @@ var init_evalsRagasCorrectness2 = __esm(() => {
 
 // src/funcs/evalsRagasFaithfulness.ts
 function evalsRagasFaithfulness(client, request, options) {
-  return new APIPromise($do52(client, request, options));
+  return new APIPromise($do53(client, request, options));
 }
-async function $do52(client, request, options) {
+async function $do53(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasFaithfulnessRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70879,20 +71440,20 @@ var init_evalsRagasFaithfulness = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasFaithfulness.ts
-var args52, tool$evalsRagasFaithfulness;
+var args53, tool$evalsRagasFaithfulness;
 var init_evalsRagasFaithfulness2 = __esm(() => {
   init_evalsRagasFaithfulness();
   init_operations();
   init_tools();
-  args52 = {
+  args53 = {
     request: EvalsRagasFaithfulnessRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasFaithfulness = {
     name: "evals-ragas-faithfulness",
     description: `Run Faithfulness Evaluator`,
-    args: args52,
-    tool: async (client, args53, ctx) => {
-      const [result, apiCall] = await evalsRagasFaithfulness(client, args53.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args53,
+    tool: async (client, args54, ctx) => {
+      const [result, apiCall] = await evalsRagasFaithfulness(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -70907,9 +71468,9 @@ var init_evalsRagasFaithfulness2 = __esm(() => {
 
 // src/funcs/evalsRagasHarmfulness.ts
 function evalsRagasHarmfulness(client, request, options) {
-  return new APIPromise($do53(client, request, options));
+  return new APIPromise($do54(client, request, options));
 }
-async function $do53(client, request, options) {
+async function $do54(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasHarmfulnessRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -70980,20 +71541,20 @@ var init_evalsRagasHarmfulness = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasHarmfulness.ts
-var args53, tool$evalsRagasHarmfulness;
+var args54, tool$evalsRagasHarmfulness;
 var init_evalsRagasHarmfulness2 = __esm(() => {
   init_evalsRagasHarmfulness();
   init_operations();
   init_tools();
-  args53 = {
+  args54 = {
     request: EvalsRagasHarmfulnessRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasHarmfulness = {
     name: "evals-ragas-harmfulness",
     description: `Run Harmfulness Evaluator`,
-    args: args53,
-    tool: async (client, args54, ctx) => {
-      const [result, apiCall] = await evalsRagasHarmfulness(client, args54.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args54,
+    tool: async (client, args55, ctx) => {
+      const [result, apiCall] = await evalsRagasHarmfulness(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71008,9 +71569,9 @@ var init_evalsRagasHarmfulness2 = __esm(() => {
 
 // src/funcs/evalsRagasMaliciousness.ts
 function evalsRagasMaliciousness(client, request, options) {
-  return new APIPromise($do54(client, request, options));
+  return new APIPromise($do55(client, request, options));
 }
-async function $do54(client, request, options) {
+async function $do55(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasMaliciousnessRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71081,20 +71642,20 @@ var init_evalsRagasMaliciousness = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasMaliciousness.ts
-var args54, tool$evalsRagasMaliciousness;
+var args55, tool$evalsRagasMaliciousness;
 var init_evalsRagasMaliciousness2 = __esm(() => {
   init_evalsRagasMaliciousness();
   init_operations();
   init_tools();
-  args54 = {
+  args55 = {
     request: EvalsRagasMaliciousnessRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasMaliciousness = {
     name: "evals-ragas-maliciousness",
     description: `Run Maliciousness Evaluator`,
-    args: args54,
-    tool: async (client, args55, ctx) => {
-      const [result, apiCall] = await evalsRagasMaliciousness(client, args55.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args55,
+    tool: async (client, args56, ctx) => {
+      const [result, apiCall] = await evalsRagasMaliciousness(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71109,9 +71670,9 @@ var init_evalsRagasMaliciousness2 = __esm(() => {
 
 // src/funcs/evalsRagasNoiseSensitivity.ts
 function evalsRagasNoiseSensitivity(client, request, options) {
-  return new APIPromise($do55(client, request, options));
+  return new APIPromise($do56(client, request, options));
 }
-async function $do55(client, request, options) {
+async function $do56(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasNoiseSensitivityRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71182,20 +71743,20 @@ var init_evalsRagasNoiseSensitivity = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasNoiseSensitivity.ts
-var args55, tool$evalsRagasNoiseSensitivity;
+var args56, tool$evalsRagasNoiseSensitivity;
 var init_evalsRagasNoiseSensitivity2 = __esm(() => {
   init_evalsRagasNoiseSensitivity();
   init_operations();
   init_tools();
-  args55 = {
+  args56 = {
     request: EvalsRagasNoiseSensitivityRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasNoiseSensitivity = {
     name: "evals-ragas-noise-sensitivity",
     description: `Run Noise Sensitivity Evaluator`,
-    args: args55,
-    tool: async (client, args56, ctx) => {
-      const [result, apiCall] = await evalsRagasNoiseSensitivity(client, args56.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args56,
+    tool: async (client, args57, ctx) => {
+      const [result, apiCall] = await evalsRagasNoiseSensitivity(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71210,9 +71771,9 @@ var init_evalsRagasNoiseSensitivity2 = __esm(() => {
 
 // src/funcs/evalsRagasResponseRelevancy.ts
 function evalsRagasResponseRelevancy(client, request, options) {
-  return new APIPromise($do56(client, request, options));
+  return new APIPromise($do57(client, request, options));
 }
-async function $do56(client, request, options) {
+async function $do57(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasResponseRelevancyRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71283,20 +71844,20 @@ var init_evalsRagasResponseRelevancy = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasResponseRelevancy.ts
-var args56, tool$evalsRagasResponseRelevancy;
+var args57, tool$evalsRagasResponseRelevancy;
 var init_evalsRagasResponseRelevancy2 = __esm(() => {
   init_evalsRagasResponseRelevancy();
   init_operations();
   init_tools();
-  args56 = {
+  args57 = {
     request: EvalsRagasResponseRelevancyRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasResponseRelevancy = {
     name: "evals-ragas-response-relevancy",
     description: `Run Response Relevancy Evaluator`,
-    args: args56,
-    tool: async (client, args57, ctx) => {
-      const [result, apiCall] = await evalsRagasResponseRelevancy(client, args57.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args57,
+    tool: async (client, args58, ctx) => {
+      const [result, apiCall] = await evalsRagasResponseRelevancy(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71311,9 +71872,9 @@ var init_evalsRagasResponseRelevancy2 = __esm(() => {
 
 // src/funcs/evalsRagasSummarization.ts
 function evalsRagasSummarization(client, request, options) {
-  return new APIPromise($do57(client, request, options));
+  return new APIPromise($do58(client, request, options));
 }
-async function $do57(client, request, options) {
+async function $do58(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsRagasSummarizationRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71384,20 +71945,20 @@ var init_evalsRagasSummarization = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsRagasSummarization.ts
-var args57, tool$evalsRagasSummarization;
+var args58, tool$evalsRagasSummarization;
 var init_evalsRagasSummarization2 = __esm(() => {
   init_evalsRagasSummarization();
   init_operations();
   init_tools();
-  args57 = {
+  args58 = {
     request: EvalsRagasSummarizationRequestBody$inboundSchema.optional()
   };
   tool$evalsRagasSummarization = {
     name: "evals-ragas-summarization",
     description: `Run Summarization Evaluator`,
-    args: args57,
-    tool: async (client, args58, ctx) => {
-      const [result, apiCall] = await evalsRagasSummarization(client, args58.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args58,
+    tool: async (client, args59, ctx) => {
+      const [result, apiCall] = await evalsRagasSummarization(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71412,9 +71973,9 @@ var init_evalsRagasSummarization2 = __esm(() => {
 
 // src/funcs/evalsSentimentClassification.ts
 function evalsSentimentClassification(client, request, options) {
-  return new APIPromise($do58(client, request, options));
+  return new APIPromise($do59(client, request, options));
 }
-async function $do58(client, request, options) {
+async function $do59(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsSentimentClassificationRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71485,20 +72046,20 @@ var init_evalsSentimentClassification = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsSentimentClassification.ts
-var args58, tool$evalsSentimentClassification;
+var args59, tool$evalsSentimentClassification;
 var init_evalsSentimentClassification2 = __esm(() => {
   init_evalsSentimentClassification();
   init_operations();
   init_tools();
-  args58 = {
+  args59 = {
     request: EvalsSentimentClassificationRequestBody$inboundSchema.optional()
   };
   tool$evalsSentimentClassification = {
     name: "evals-sentiment-classification",
     description: `Run Sentiment Classification Evaluator`,
-    args: args58,
-    tool: async (client, args59, ctx) => {
-      const [result, apiCall] = await evalsSentimentClassification(client, args59.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args59,
+    tool: async (client, args60, ctx) => {
+      const [result, apiCall] = await evalsSentimentClassification(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71513,9 +72074,9 @@ var init_evalsSentimentClassification2 = __esm(() => {
 
 // src/funcs/evalsSummarization.ts
 function evalsSummarization(client, request, options) {
-  return new APIPromise($do59(client, request, options));
+  return new APIPromise($do60(client, request, options));
 }
-async function $do59(client, request, options) {
+async function $do60(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsSummarizationRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71586,20 +72147,20 @@ var init_evalsSummarization = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsSummarization.ts
-var args59, tool$evalsSummarization;
+var args60, tool$evalsSummarization;
 var init_evalsSummarization2 = __esm(() => {
   init_evalsSummarization();
   init_operations();
   init_tools();
-  args59 = {
+  args60 = {
     request: EvalsSummarizationRequestBody$inboundSchema.optional()
   };
   tool$evalsSummarization = {
     name: "evals-summarization",
     description: `Run Summarization Evaluator`,
-    args: args59,
-    tool: async (client, args60, ctx) => {
-      const [result, apiCall] = await evalsSummarization(client, args60.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args60,
+    tool: async (client, args61, ctx) => {
+      const [result, apiCall] = await evalsSummarization(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71614,9 +72175,9 @@ var init_evalsSummarization2 = __esm(() => {
 
 // src/funcs/evalsToneOfVoice.ts
 function evalsToneOfVoice(client, request, options) {
-  return new APIPromise($do60(client, request, options));
+  return new APIPromise($do61(client, request, options));
 }
-async function $do60(client, request, options) {
+async function $do61(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsToneOfVoiceRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71687,20 +72248,20 @@ var init_evalsToneOfVoice = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsToneOfVoice.ts
-var args60, tool$evalsToneOfVoice;
+var args61, tool$evalsToneOfVoice;
 var init_evalsToneOfVoice2 = __esm(() => {
   init_evalsToneOfVoice();
   init_operations();
   init_tools();
-  args60 = {
+  args61 = {
     request: EvalsToneOfVoiceRequestBody$inboundSchema.optional()
   };
   tool$evalsToneOfVoice = {
     name: "evals-tone-of-voice",
     description: `Run Tone of Voice Evaluator`,
-    args: args60,
-    tool: async (client, args61, ctx) => {
-      const [result, apiCall] = await evalsToneOfVoice(client, args61.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args61,
+    tool: async (client, args62, ctx) => {
+      const [result, apiCall] = await evalsToneOfVoice(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71715,9 +72276,9 @@ var init_evalsToneOfVoice2 = __esm(() => {
 
 // src/funcs/evalsTranslation.ts
 function evalsTranslation(client, request, options) {
-  return new APIPromise($do61(client, request, options));
+  return new APIPromise($do62(client, request, options));
 }
-async function $do61(client, request, options) {
+async function $do62(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsTranslationRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71788,20 +72349,20 @@ var init_evalsTranslation = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsTranslation.ts
-var args61, tool$evalsTranslation;
+var args62, tool$evalsTranslation;
 var init_evalsTranslation2 = __esm(() => {
   init_evalsTranslation();
   init_operations();
   init_tools();
-  args61 = {
+  args62 = {
     request: EvalsTranslationRequestBody$inboundSchema.optional()
   };
   tool$evalsTranslation = {
     name: "evals-translation",
     description: `Run Translation Evaluator`,
-    args: args61,
-    tool: async (client, args62, ctx) => {
-      const [result, apiCall] = await evalsTranslation(client, args62.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args62,
+    tool: async (client, args63, ctx) => {
+      const [result, apiCall] = await evalsTranslation(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71816,9 +72377,9 @@ var init_evalsTranslation2 = __esm(() => {
 
 // src/funcs/evalsUpdate.ts
 function evalsUpdate(client, request, options) {
-  return new APIPromise($do62(client, request, options));
+  return new APIPromise($do63(client, request, options));
 }
-async function $do62(client, request, options) {
+async function $do63(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateEvalRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71895,20 +72456,20 @@ var init_evalsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsUpdate.ts
-var args62, tool$evalsUpdate;
+var args63, tool$evalsUpdate;
 var init_evalsUpdate2 = __esm(() => {
   init_evalsUpdate();
   init_operations();
   init_tools();
-  args62 = {
+  args63 = {
     request: UpdateEvalRequest$inboundSchema
   };
   tool$evalsUpdate = {
     name: "evals-update",
     description: `Update an Evaluator`,
-    args: args62,
-    tool: async (client, args63, ctx) => {
-      const [result, apiCall] = await evalsUpdate(client, args63.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args63,
+    tool: async (client, args64, ctx) => {
+      const [result, apiCall] = await evalsUpdate(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -71923,9 +72484,9 @@ var init_evalsUpdate2 = __esm(() => {
 
 // src/funcs/evalsValidJson.ts
 function evalsValidJson(client, request, options) {
-  return new APIPromise($do63(client, request, options));
+  return new APIPromise($do64(client, request, options));
 }
-async function $do63(client, request, options) {
+async function $do64(client, request, options) {
   const parsed = safeParse(request, (value) => EvalsValidJsonRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -71996,20 +72557,20 @@ var init_evalsValidJson = __esm(() => {
 });
 
 // src/mcp-server/tools/evalsValidJson.ts
-var args63, tool$evalsValidJson;
+var args64, tool$evalsValidJson;
 var init_evalsValidJson2 = __esm(() => {
   init_evalsValidJson();
   init_operations();
   init_tools();
-  args63 = {
+  args64 = {
     request: EvalsValidJsonRequestBody$inboundSchema.optional()
   };
   tool$evalsValidJson = {
     name: "evals-valid-json",
     description: `Run JSON Validation Evaluator`,
-    args: args63,
-    tool: async (client, args64, ctx) => {
-      const [result, apiCall] = await evalsValidJson(client, args64.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args64,
+    tool: async (client, args65, ctx) => {
+      const [result, apiCall] = await evalsValidJson(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72024,9 +72585,9 @@ var init_evalsValidJson2 = __esm(() => {
 
 // src/funcs/feedbackCreate.ts
 function feedbackCreate(client, request, options) {
-  return new APIPromise($do64(client, request, options));
+  return new APIPromise($do65(client, request, options));
 }
-async function $do64(client, request, options) {
+async function $do65(client, request, options) {
   const parsed = safeParse(request, (value) => CreateFeedbackRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72093,12 +72654,12 @@ var init_feedbackCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/feedbackCreate.ts
-var args64, tool$feedbackCreate;
+var args65, tool$feedbackCreate;
 var init_feedbackCreate2 = __esm(() => {
   init_feedbackCreate();
   init_operations();
   init_tools();
-  args64 = {
+  args65 = {
     request: CreateFeedbackRequestBody$inboundSchema
   };
   tool$feedbackCreate = {
@@ -72106,9 +72667,9 @@ var init_feedbackCreate2 = __esm(() => {
     description: `Submit feedback
 
 Submit feedback for the LLM transaction via the API`,
-    args: args64,
-    tool: async (client, args65, ctx) => {
-      const [result, apiCall] = await feedbackCreate(client, args65.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args65,
+    tool: async (client, args66, ctx) => {
+      const [result, apiCall] = await feedbackCreate(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72192,9 +72753,9 @@ function isReadableStream(val) {
 
 // src/funcs/filesCreate.ts
 function filesCreate(client, request, options) {
-  return new APIPromise($do65(client, request, options));
+  return new APIPromise($do66(client, request, options));
 }
-async function $do65(client, request, options) {
+async function $do66(client, request, options) {
   const parsed = safeParse(request, (value) => FileUploadRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72275,12 +72836,12 @@ var init_filesCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/filesCreate.ts
-var args65, tool$filesCreate;
+var args66, tool$filesCreate;
 var init_filesCreate2 = __esm(() => {
   init_filesCreate();
   init_operations();
   init_tools();
-  args65 = {
+  args66 = {
     request: FileUploadRequestBody$inboundSchema
   };
   tool$filesCreate = {
@@ -72288,9 +72849,9 @@ var init_filesCreate2 = __esm(() => {
     description: `Create file
 
 Files are used to upload documents that can be used with features like [Deployments](https://docs.orq.ai/reference/deploymentinvoke-1).`,
-    args: args65,
-    tool: async (client, args66, ctx) => {
-      const [result, apiCall] = await filesCreate(client, args66.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args66,
+    tool: async (client, args67, ctx) => {
+      const [result, apiCall] = await filesCreate(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72305,9 +72866,9 @@ Files are used to upload documents that can be used with features like [Deployme
 
 // src/funcs/filesDelete.ts
 function filesDelete(client, request, options) {
-  return new APIPromise($do66(client, request, options));
+  return new APIPromise($do67(client, request, options));
 }
-async function $do66(client, request, options) {
+async function $do67(client, request, options) {
   const parsed = safeParse(request, (value) => FileDeleteRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72380,20 +72941,20 @@ var init_filesDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/filesDelete.ts
-var args66, tool$filesDelete;
+var args67, tool$filesDelete;
 var init_filesDelete2 = __esm(() => {
   init_filesDelete();
   init_operations();
   init_tools();
-  args66 = {
+  args67 = {
     request: FileDeleteRequest$inboundSchema
   };
   tool$filesDelete = {
     name: "files-delete",
     description: `Delete file`,
-    args: args66,
-    tool: async (client, args67, ctx) => {
-      const [result, apiCall] = await filesDelete(client, args67.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args67,
+    tool: async (client, args68, ctx) => {
+      const [result, apiCall] = await filesDelete(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72407,9 +72968,9 @@ var init_filesDelete2 = __esm(() => {
 
 // src/funcs/filesGet.ts
 function filesGet(client, request, options) {
-  return new APIPromise($do67(client, request, options));
+  return new APIPromise($do68(client, request, options));
 }
-async function $do67(client, request, options) {
+async function $do68(client, request, options) {
   const parsed = safeParse(request, (value) => FileGetRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72481,12 +73042,12 @@ var init_filesGet = __esm(() => {
 });
 
 // src/mcp-server/tools/filesGet.ts
-var args67, tool$filesGet;
+var args68, tool$filesGet;
 var init_filesGet2 = __esm(() => {
   init_filesGet();
   init_operations();
   init_tools();
-  args67 = {
+  args68 = {
     request: FileGetRequest$inboundSchema
   };
   tool$filesGet = {
@@ -72494,9 +73055,9 @@ var init_filesGet2 = __esm(() => {
     description: `Retrieve a file
 
 Retrieves the details of an existing file object. After you supply a unique file ID, orq.ai returns the corresponding file object`,
-    args: args67,
-    tool: async (client, args68, ctx) => {
-      const [result, apiCall] = await filesGet(client, args68.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args68,
+    tool: async (client, args69, ctx) => {
+      const [result, apiCall] = await filesGet(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72511,9 +73072,9 @@ Retrieves the details of an existing file object. After you supply a unique file
 
 // src/funcs/filesList.ts
 function filesList(client, request, options) {
-  return new APIPromise($do68(client, request, options));
+  return new APIPromise($do69(client, request, options));
 }
-async function $do68(client, request, options) {
+async function $do69(client, request, options) {
   const parsed = safeParse(request, (value) => FileListRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72585,12 +73146,12 @@ var init_filesList = __esm(() => {
 });
 
 // src/mcp-server/tools/filesList.ts
-var args68, tool$filesList;
+var args69, tool$filesList;
 var init_filesList2 = __esm(() => {
   init_filesList();
   init_operations();
   init_tools();
-  args68 = {
+  args69 = {
     request: FileListRequest$inboundSchema.optional()
   };
   tool$filesList = {
@@ -72598,9 +73159,9 @@ var init_filesList2 = __esm(() => {
     description: `List all files
 
 Returns a list of the files that your account has access to. orq.ai sorts and returns the files by their creation dates, placing the most recently created files at the top.`,
-    args: args68,
-    tool: async (client, args69, ctx) => {
-      const [result, apiCall] = await filesList(client, args69.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args69,
+    tool: async (client, args70, ctx) => {
+      const [result, apiCall] = await filesList(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72615,9 +73176,9 @@ Returns a list of the files that your account has access to. orq.ai sorts and re
 
 // src/funcs/knowledgeCreate.ts
 function knowledgeCreate(client, request, options) {
-  return new APIPromise($do69(client, request, options));
+  return new APIPromise($do70(client, request, options));
 }
-async function $do69(client, request, options) {
+async function $do70(client, request, options) {
   const parsed = safeParse(request, (value) => CreateKnowledgeRequestBody$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72684,20 +73245,20 @@ var init_knowledgeCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeCreate.ts
-var args69, tool$knowledgeCreate;
+var args70, tool$knowledgeCreate;
 var init_knowledgeCreate2 = __esm(() => {
   init_knowledgeCreate();
   init_operations();
   init_tools();
-  args69 = {
+  args70 = {
     request: CreateKnowledgeRequestBody$inboundSchema
   };
   tool$knowledgeCreate = {
     name: "knowledge-create",
     description: `Create a knowledge`,
-    args: args69,
-    tool: async (client, args70, ctx) => {
-      const [result, apiCall] = await knowledgeCreate(client, args70.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args70,
+    tool: async (client, args71, ctx) => {
+      const [result, apiCall] = await knowledgeCreate(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72712,9 +73273,9 @@ var init_knowledgeCreate2 = __esm(() => {
 
 // src/funcs/knowledgeCreateChunks.ts
 function knowledgeCreateChunks(client, request, options) {
-  return new APIPromise($do70(client, request, options));
+  return new APIPromise($do71(client, request, options));
 }
-async function $do70(client, request, options) {
+async function $do71(client, request, options) {
   const parsed = safeParse(request, (value) => CreateChunkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72792,20 +73353,20 @@ var init_knowledgeCreateChunks = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeCreateChunks.ts
-var args70, tool$knowledgeCreateChunks;
+var args71, tool$knowledgeCreateChunks;
 var init_knowledgeCreateChunks2 = __esm(() => {
   init_knowledgeCreateChunks();
   init_operations();
   init_tools();
-  args70 = {
+  args71 = {
     request: CreateChunkRequest$inboundSchema
   };
   tool$knowledgeCreateChunks = {
     name: "knowledge-create-chunks",
     description: `Create chunks for a datasource`,
-    args: args70,
-    tool: async (client, args71, ctx) => {
-      const [result, apiCall] = await knowledgeCreateChunks(client, args71.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args71,
+    tool: async (client, args72, ctx) => {
+      const [result, apiCall] = await knowledgeCreateChunks(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72820,9 +73381,9 @@ var init_knowledgeCreateChunks2 = __esm(() => {
 
 // src/funcs/knowledgeCreateDatasource.ts
 function knowledgeCreateDatasource(client, request, options) {
-  return new APIPromise($do71(client, request, options));
+  return new APIPromise($do72(client, request, options));
 }
-async function $do71(client, request, options) {
+async function $do72(client, request, options) {
   const parsed = safeParse(request, (value) => CreateDatasourceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72895,20 +73456,20 @@ var init_knowledgeCreateDatasource = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeCreateDatasource.ts
-var args71, tool$knowledgeCreateDatasource;
+var args72, tool$knowledgeCreateDatasource;
 var init_knowledgeCreateDatasource2 = __esm(() => {
   init_knowledgeCreateDatasource();
   init_operations();
   init_tools();
-  args71 = {
+  args72 = {
     request: CreateDatasourceRequest$inboundSchema
   };
   tool$knowledgeCreateDatasource = {
     name: "knowledge-create-datasource",
     description: `Create a new datasource`,
-    args: args71,
-    tool: async (client, args72, ctx) => {
-      const [result, apiCall] = await knowledgeCreateDatasource(client, args72.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args72,
+    tool: async (client, args73, ctx) => {
+      const [result, apiCall] = await knowledgeCreateDatasource(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -72923,9 +73484,9 @@ var init_knowledgeCreateDatasource2 = __esm(() => {
 
 // src/funcs/knowledgeDelete.ts
 function knowledgeDelete(client, request, options) {
-  return new APIPromise($do72(client, request, options));
+  return new APIPromise($do73(client, request, options));
 }
-async function $do72(client, request, options) {
+async function $do73(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteKnowledgeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -72998,12 +73559,12 @@ var init_knowledgeDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeDelete.ts
-var args72, tool$knowledgeDelete;
+var args73, tool$knowledgeDelete;
 var init_knowledgeDelete2 = __esm(() => {
   init_knowledgeDelete();
   init_operations();
   init_tools();
-  args72 = {
+  args73 = {
     request: DeleteKnowledgeRequest$inboundSchema
   };
   tool$knowledgeDelete = {
@@ -73011,9 +73572,9 @@ var init_knowledgeDelete2 = __esm(() => {
     description: `Deletes a knowledge
 
 Deletes a knowledge base. Deleting a knowledge base will delete all the datasources and chunks associated with it.`,
-    args: args72,
-    tool: async (client, args73, ctx) => {
-      const [result, apiCall] = await knowledgeDelete(client, args73.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args73,
+    tool: async (client, args74, ctx) => {
+      const [result, apiCall] = await knowledgeDelete(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73027,9 +73588,9 @@ Deletes a knowledge base. Deleting a knowledge base will delete all the datasour
 
 // src/funcs/knowledgeDeleteChunk.ts
 function knowledgeDeleteChunk(client, request, options) {
-  return new APIPromise($do73(client, request, options));
+  return new APIPromise($do74(client, request, options));
 }
-async function $do73(client, request, options) {
+async function $do74(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteChunkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73110,20 +73671,20 @@ var init_knowledgeDeleteChunk = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeDeleteChunk.ts
-var args73, tool$knowledgeDeleteChunk;
+var args74, tool$knowledgeDeleteChunk;
 var init_knowledgeDeleteChunk2 = __esm(() => {
   init_knowledgeDeleteChunk();
   init_operations();
   init_tools();
-  args73 = {
+  args74 = {
     request: DeleteChunkRequest$inboundSchema
   };
   tool$knowledgeDeleteChunk = {
     name: "knowledge-delete-chunk",
     description: `Delete a chunk`,
-    args: args73,
-    tool: async (client, args74, ctx) => {
-      const [result, apiCall] = await knowledgeDeleteChunk(client, args74.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args74,
+    tool: async (client, args75, ctx) => {
+      const [result, apiCall] = await knowledgeDeleteChunk(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73137,9 +73698,9 @@ var init_knowledgeDeleteChunk2 = __esm(() => {
 
 // src/funcs/knowledgeDeleteDatasource.ts
 function knowledgeDeleteDatasource(client, request, options) {
-  return new APIPromise($do74(client, request, options));
+  return new APIPromise($do75(client, request, options));
 }
-async function $do74(client, request, options) {
+async function $do75(client, request, options) {
   const parsed = safeParse(request, (value) => DeleteDatasourceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73216,12 +73777,12 @@ var init_knowledgeDeleteDatasource = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeDeleteDatasource.ts
-var args74, tool$knowledgeDeleteDatasource;
+var args75, tool$knowledgeDeleteDatasource;
 var init_knowledgeDeleteDatasource2 = __esm(() => {
   init_knowledgeDeleteDatasource();
   init_operations();
   init_tools();
-  args74 = {
+  args75 = {
     request: DeleteDatasourceRequest$inboundSchema
   };
   tool$knowledgeDeleteDatasource = {
@@ -73229,9 +73790,9 @@ var init_knowledgeDeleteDatasource2 = __esm(() => {
     description: `Deletes a datasource
 
 Deletes a datasource from a knowledge base. Deleting a datasource will remove it from the knowledge base and all associated chunks. This action is irreversible and cannot be undone.`,
-    args: args74,
-    tool: async (client, args75, ctx) => {
-      const [result, apiCall] = await knowledgeDeleteDatasource(client, args75.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args75,
+    tool: async (client, args76, ctx) => {
+      const [result, apiCall] = await knowledgeDeleteDatasource(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73245,9 +73806,9 @@ Deletes a datasource from a knowledge base. Deleting a datasource will remove it
 
 // src/funcs/knowledgeList.ts
 function knowledgeList(client, request, options) {
-  return new APIPromise($do75(client, request, options));
+  return new APIPromise($do76(client, request, options));
 }
-async function $do75(client, request, options) {
+async function $do76(client, request, options) {
   const parsed = safeParse(request, (value) => ListKnowledgeBasesRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73319,12 +73880,12 @@ var init_knowledgeList = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeList.ts
-var args75, tool$knowledgeList;
+var args76, tool$knowledgeList;
 var init_knowledgeList2 = __esm(() => {
   init_knowledgeList();
   init_operations();
   init_tools();
-  args75 = {
+  args76 = {
     request: ListKnowledgeBasesRequest$inboundSchema.optional()
   };
   tool$knowledgeList = {
@@ -73332,9 +73893,9 @@ var init_knowledgeList2 = __esm(() => {
     description: `List all knowledge bases
 
 Returns a list of your knowledge bases. The knowledge bases are returned sorted by creation date, with the most recent knowledge bases appearing first`,
-    args: args75,
-    tool: async (client, args76, ctx) => {
-      const [result, apiCall] = await knowledgeList(client, args76.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args76,
+    tool: async (client, args77, ctx) => {
+      const [result, apiCall] = await knowledgeList(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73349,9 +73910,9 @@ Returns a list of your knowledge bases. The knowledge bases are returned sorted
 
 // src/funcs/knowledgeListChunks.ts
 function knowledgeListChunks(client, request, options) {
-  return new APIPromise($do76(client, request, options));
+  return new APIPromise($do77(client, request, options));
 }
-async function $do76(client, request, options) {
+async function $do77(client, request, options) {
   const parsed = safeParse(request, (value) => ListChunksRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73435,20 +73996,20 @@ var init_knowledgeListChunks = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeListChunks.ts
-var args76, tool$knowledgeListChunks;
+var args77, tool$knowledgeListChunks;
 var init_knowledgeListChunks2 = __esm(() => {
   init_knowledgeListChunks();
   init_operations();
   init_tools();
-  args76 = {
+  args77 = {
     request: ListChunksRequest$inboundSchema
   };
   tool$knowledgeListChunks = {
     name: "knowledge-list-chunks",
     description: `List all chunks for a datasource`,
-    args: args76,
-    tool: async (client, args77, ctx) => {
-      const [result, apiCall] = await knowledgeListChunks(client, args77.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args77,
+    tool: async (client, args78, ctx) => {
+      const [result, apiCall] = await knowledgeListChunks(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73463,9 +74024,9 @@ var init_knowledgeListChunks2 = __esm(() => {
 
 // src/funcs/knowledgeListDatasources.ts
 function knowledgeListDatasources(client, request, options) {
-  return new APIPromise($do77(client, request, options));
+  return new APIPromise($do78(client, request, options));
 }
-async function $do77(client, request, options) {
+async function $do78(client, request, options) {
   const parsed = safeParse(request, (value) => ListDatasourcesRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73545,20 +74106,20 @@ var init_knowledgeListDatasources = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeListDatasources.ts
-var args77, tool$knowledgeListDatasources;
+var args78, tool$knowledgeListDatasources;
 var init_knowledgeListDatasources2 = __esm(() => {
   init_knowledgeListDatasources();
   init_operations();
   init_tools();
-  args77 = {
+  args78 = {
     request: ListDatasourcesRequest$inboundSchema
   };
   tool$knowledgeListDatasources = {
     name: "knowledge-list-datasources",
     description: `List all datasources`,
-    args: args77,
-    tool: async (client, args78, ctx) => {
-      const [result, apiCall] = await knowledgeListDatasources(client, args78.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args78,
+    tool: async (client, args79, ctx) => {
+      const [result, apiCall] = await knowledgeListDatasources(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73573,9 +74134,9 @@ var init_knowledgeListDatasources2 = __esm(() => {
 
 // src/funcs/knowledgeRetrieve.ts
 function knowledgeRetrieve(client, request, options) {
-  return new APIPromise($do78(client, request, options));
+  return new APIPromise($do79(client, request, options));
 }
-async function $do78(client, request, options) {
+async function $do79(client, request, options) {
   const parsed = safeParse(request, (value) => GetOneKnowledgeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73647,12 +74208,12 @@ var init_knowledgeRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeRetrieve.ts
-var args78, tool$knowledgeRetrieve;
+var args79, tool$knowledgeRetrieve;
 var init_knowledgeRetrieve2 = __esm(() => {
   init_knowledgeRetrieve();
   init_operations();
   init_tools();
-  args78 = {
+  args79 = {
     request: GetOneKnowledgeRequest$inboundSchema
   };
   tool$knowledgeRetrieve = {
@@ -73660,9 +74221,9 @@ var init_knowledgeRetrieve2 = __esm(() => {
     description: `Retrieves a knowledge base
 
 Retrieve a knowledge base with the settings.`,
-    args: args78,
-    tool: async (client, args79, ctx) => {
-      const [result, apiCall] = await knowledgeRetrieve(client, args79.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args79,
+    tool: async (client, args80, ctx) => {
+      const [result, apiCall] = await knowledgeRetrieve(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73677,9 +74238,9 @@ Retrieve a knowledge base with the settings.`,
 
 // src/funcs/knowledgeRetrieveChunk.ts
 function knowledgeRetrieveChunk(client, request, options) {
-  return new APIPromise($do79(client, request, options));
+  return new APIPromise($do80(client, request, options));
 }
-async function $do79(client, request, options) {
+async function $do80(client, request, options) {
   const parsed = safeParse(request, (value) => GetOneChunkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73759,20 +74320,20 @@ var init_knowledgeRetrieveChunk = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeRetrieveChunk.ts
-var args79, tool$knowledgeRetrieveChunk;
+var args80, tool$knowledgeRetrieveChunk;
 var init_knowledgeRetrieveChunk2 = __esm(() => {
   init_knowledgeRetrieveChunk();
   init_operations();
   init_tools();
-  args79 = {
+  args80 = {
     request: GetOneChunkRequest$inboundSchema
   };
   tool$knowledgeRetrieveChunk = {
     name: "knowledge-retrieve-chunk",
     description: `Retrieve a chunk`,
-    args: args79,
-    tool: async (client, args80, ctx) => {
-      const [result, apiCall] = await knowledgeRetrieveChunk(client, args80.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args80,
+    tool: async (client, args81, ctx) => {
+      const [result, apiCall] = await knowledgeRetrieveChunk(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73787,9 +74348,9 @@ var init_knowledgeRetrieveChunk2 = __esm(() => {
 
 // src/funcs/knowledgeRetrieveDatasource.ts
 function knowledgeRetrieveDatasource(client, request, options) {
-  return new APIPromise($do80(client, request, options));
+  return new APIPromise($do81(client, request, options));
 }
-async function $do80(client, request, options) {
+async function $do81(client, request, options) {
   const parsed = safeParse(request, (value) => RetrieveDatasourceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73865,20 +74426,20 @@ var init_knowledgeRetrieveDatasource = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeRetrieveDatasource.ts
-var args80, tool$knowledgeRetrieveDatasource;
+var args81, tool$knowledgeRetrieveDatasource;
 var init_knowledgeRetrieveDatasource2 = __esm(() => {
   init_knowledgeRetrieveDatasource();
   init_operations();
   init_tools();
-  args80 = {
+  args81 = {
     request: RetrieveDatasourceRequest$inboundSchema
   };
   tool$knowledgeRetrieveDatasource = {
     name: "knowledge-retrieve-datasource",
     description: `Retrieve a datasource`,
-    args: args80,
-    tool: async (client, args81, ctx) => {
-      const [result, apiCall] = await knowledgeRetrieveDatasource(client, args81.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args81,
+    tool: async (client, args82, ctx) => {
+      const [result, apiCall] = await knowledgeRetrieveDatasource(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73893,9 +74454,9 @@ var init_knowledgeRetrieveDatasource2 = __esm(() => {
 
 // src/funcs/knowledgeSearch.ts
 function knowledgeSearch(client, request, options) {
-  return new APIPromise($do81(client, request, options));
+  return new APIPromise($do82(client, request, options));
 }
-async function $do81(client, request, options) {
+async function $do82(client, request, options) {
   const parsed = safeParse(request, (value) => SearchKnowledgeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -73968,12 +74529,12 @@ var init_knowledgeSearch = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeSearch.ts
-var args81, tool$knowledgeSearch;
+var args82, tool$knowledgeSearch;
 var init_knowledgeSearch2 = __esm(() => {
   init_knowledgeSearch();
   init_operations();
   init_tools();
-  args81 = {
+  args82 = {
     request: SearchKnowledgeRequest$inboundSchema
   };
   tool$knowledgeSearch = {
@@ -73981,9 +74542,9 @@ var init_knowledgeSearch2 = __esm(() => {
     description: `Search knowledge base
 
 Search a Knowledge Base and return the most similar chunks, along with their search and rerank scores.`,
-    args: args81,
-    tool: async (client, args82, ctx) => {
-      const [result, apiCall] = await knowledgeSearch(client, args82.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args82,
+    tool: async (client, args83, ctx) => {
+      const [result, apiCall] = await knowledgeSearch(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -73998,9 +74559,9 @@ Search a Knowledge Base and return the most similar chunks, along with their sea
 
 // src/funcs/knowledgeUpdate.ts
 function knowledgeUpdate(client, request, options) {
-  return new APIPromise($do82(client, request, options));
+  return new APIPromise($do83(client, request, options));
 }
-async function $do82(client, request, options) {
+async function $do83(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateKnowledgeRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74073,20 +74634,20 @@ var init_knowledgeUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeUpdate.ts
-var args82, tool$knowledgeUpdate;
+var args83, tool$knowledgeUpdate;
 var init_knowledgeUpdate2 = __esm(() => {
   init_knowledgeUpdate();
   init_operations();
   init_tools();
-  args82 = {
+  args83 = {
     request: UpdateKnowledgeRequest$inboundSchema
   };
   tool$knowledgeUpdate = {
     name: "knowledge-update",
     description: `Updates a knowledge`,
-    args: args82,
-    tool: async (client, args83, ctx) => {
-      const [result, apiCall] = await knowledgeUpdate(client, args83.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args83,
+    tool: async (client, args84, ctx) => {
+      const [result, apiCall] = await knowledgeUpdate(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74101,9 +74662,9 @@ var init_knowledgeUpdate2 = __esm(() => {
 
 // src/funcs/knowledgeUpdateChunk.ts
 function knowledgeUpdateChunk(client, request, options) {
-  return new APIPromise($do83(client, request, options));
+  return new APIPromise($do84(client, request, options));
 }
-async function $do83(client, request, options) {
+async function $do84(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateChunkRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74184,20 +74745,20 @@ var init_knowledgeUpdateChunk = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeUpdateChunk.ts
-var args83, tool$knowledgeUpdateChunk;
+var args84, tool$knowledgeUpdateChunk;
 var init_knowledgeUpdateChunk2 = __esm(() => {
   init_knowledgeUpdateChunk();
   init_operations();
   init_tools();
-  args83 = {
+  args84 = {
     request: UpdateChunkRequest$inboundSchema
   };
   tool$knowledgeUpdateChunk = {
     name: "knowledge-update-chunk",
     description: `Update a chunk`,
-    args: args83,
-    tool: async (client, args84, ctx) => {
-      const [result, apiCall] = await knowledgeUpdateChunk(client, args84.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args84,
+    tool: async (client, args85, ctx) => {
+      const [result, apiCall] = await knowledgeUpdateChunk(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74212,9 +74773,9 @@ var init_knowledgeUpdateChunk2 = __esm(() => {
 
 // src/funcs/knowledgeUpdateDatasource.ts
 function knowledgeUpdateDatasource(client, request, options) {
-  return new APIPromise($do84(client, request, options));
+  return new APIPromise($do85(client, request, options));
 }
-async function $do84(client, request, options) {
+async function $do85(client, request, options) {
   const parsed = safeParse(request, (value) => UpdateDatasourceRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74291,20 +74852,20 @@ var init_knowledgeUpdateDatasource = __esm(() => {
 });
 
 // src/mcp-server/tools/knowledgeUpdateDatasource.ts
-var args84, tool$knowledgeUpdateDatasource;
+var args85, tool$knowledgeUpdateDatasource;
 var init_knowledgeUpdateDatasource2 = __esm(() => {
   init_knowledgeUpdateDatasource();
   init_operations();
   init_tools();
-  args84 = {
+  args85 = {
     request: UpdateDatasourceRequest$inboundSchema
   };
   tool$knowledgeUpdateDatasource = {
     name: "knowledge-update-datasource",
     description: `Update a datasource`,
-    args: args84,
-    tool: async (client, args85, ctx) => {
-      const [result, apiCall] = await knowledgeUpdateDatasource(client, args85.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args85,
+    tool: async (client, args86, ctx) => {
+      const [result, apiCall] = await knowledgeUpdateDatasource(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74319,9 +74880,9 @@ var init_knowledgeUpdateDatasource2 = __esm(() => {
 
 // src/funcs/modelsList.ts
 function modelsList(client, options) {
-  return new APIPromise($do85(client, options));
+  return new APIPromise($do86(client, options));
 }
-async function $do85(client, options) {
+async function $do86(client, options) {
   const path = pathToFunc("/v2/models")();
   const headers = new Headers(compactMap({
     Accept: "application/json"
@@ -74403,9 +74964,9 @@ Lists the currently available models, and provides basic information about each
 
 // src/funcs/promptsCreate.ts
 function promptsCreate(client, request, options) {
-  return new APIPromise($do86(client, request, options));
+  return new APIPromise($do87(client, request, options));
 }
-async function $do86(client, request, options) {
+async function $do87(client, request, options) {
   const parsed = safeParse(request, (value) => CreatePromptRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74472,20 +75033,20 @@ var init_promptsCreate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsCreate.ts
-var args85, tool$promptsCreate;
+var args86, tool$promptsCreate;
 var init_promptsCreate2 = __esm(() => {
   init_promptsCreate();
   init_operations();
   init_tools();
-  args85 = {
+  args86 = {
     request: CreatePromptRequestBody$inboundSchema.optional()
   };
   tool$promptsCreate = {
     name: "prompts-create",
     description: `Create a prompt`,
-    args: args85,
-    tool: async (client, args86, ctx) => {
-      const [result, apiCall] = await promptsCreate(client, args86.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args86,
+    tool: async (client, args87, ctx) => {
+      const [result, apiCall] = await promptsCreate(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74500,9 +75061,9 @@ var init_promptsCreate2 = __esm(() => {
 
 // src/funcs/promptsDelete.ts
 function promptsDelete(client, request, options) {
-  return new APIPromise($do87(client, request, options));
+  return new APIPromise($do88(client, request, options));
 }
-async function $do87(client, request, options) {
+async function $do88(client, request, options) {
   const parsed = safeParse(request, (value) => DeletePromptRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74575,20 +75136,20 @@ var init_promptsDelete = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsDelete.ts
-var args86, tool$promptsDelete;
+var args87, tool$promptsDelete;
 var init_promptsDelete2 = __esm(() => {
   init_promptsDelete();
   init_operations();
   init_tools();
-  args86 = {
+  args87 = {
     request: DeletePromptRequest$inboundSchema
   };
   tool$promptsDelete = {
     name: "prompts-delete",
     description: `Delete a prompt`,
-    args: args86,
-    tool: async (client, args87, ctx) => {
-      const [result, apiCall] = await promptsDelete(client, args87.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args87,
+    tool: async (client, args88, ctx) => {
+      const [result, apiCall] = await promptsDelete(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74602,9 +75163,9 @@ var init_promptsDelete2 = __esm(() => {
 
 // src/funcs/promptsGetVersion.ts
 function promptsGetVersion(client, request, options) {
-  return new APIPromise($do88(client, request, options));
+  return new APIPromise($do89(client, request, options));
 }
-async function $do88(client, request, options) {
+async function $do89(client, request, options) {
   const parsed = safeParse(request, (value) => GetPromptVersionRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74684,12 +75245,12 @@ var init_promptsGetVersion = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsGetVersion.ts
-var args87, tool$promptsGetVersion;
+var args88, tool$promptsGetVersion;
 var init_promptsGetVersion2 = __esm(() => {
   init_promptsGetVersion();
   init_operations();
   init_tools();
-  args87 = {
+  args88 = {
     request: GetPromptVersionRequest$inboundSchema
   };
   tool$promptsGetVersion = {
@@ -74697,9 +75258,9 @@ var init_promptsGetVersion2 = __esm(() => {
     description: `Retrieve a prompt version
 
 Retrieves a specific version of a prompt by its ID and version ID.`,
-    args: args87,
-    tool: async (client, args88, ctx) => {
-      const [result, apiCall] = await promptsGetVersion(client, args88.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args88,
+    tool: async (client, args89, ctx) => {
+      const [result, apiCall] = await promptsGetVersion(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74714,9 +75275,9 @@ Retrieves a specific version of a prompt by its ID and version ID.`,
 
 // src/funcs/promptsList.ts
 function promptsList(client, request, options) {
-  return new APIPromise($do89(client, request, options));
+  return new APIPromise($do90(client, request, options));
 }
-async function $do89(client, request, options) {
+async function $do90(client, request, options) {
   const parsed = safeParse(request, (value) => GetAllPromptsRequest$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74788,12 +75349,12 @@ var init_promptsList = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsList.ts
-var args88, tool$promptsList;
+var args89, tool$promptsList;
 var init_promptsList2 = __esm(() => {
   init_promptsList();
   init_operations();
   init_tools();
-  args88 = {
+  args89 = {
     request: GetAllPromptsRequest$inboundSchema.optional()
   };
   tool$promptsList = {
@@ -74801,9 +75362,9 @@ var init_promptsList2 = __esm(() => {
     description: `List all prompts
 
 Returns a list of your prompts. The prompts are returned sorted by creation date, with the most recent prompts appearing first`,
-    args: args88,
-    tool: async (client, args89, ctx) => {
-      const [result, apiCall] = await promptsList(client, args89.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args89,
+    tool: async (client, args90, ctx) => {
+      const [result, apiCall] = await promptsList(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74818,9 +75379,9 @@ Returns a list of your prompts. The prompts are returned sorted by creation date
 
 // src/funcs/promptsListVersions.ts
 function promptsListVersions(client, request, options) {
-  return new APIPromise($do90(client, request, options));
+  return new APIPromise($do91(client, request, options));
 }
-async function $do90(client, request, options) {
+async function $do91(client, request, options) {
   const parsed = safeParse(request, (value) => ListPromptVersionsRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -74898,12 +75459,12 @@ var init_promptsListVersions = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsListVersions.ts
-var args89, tool$promptsListVersions;
+var args90, tool$promptsListVersions;
 var init_promptsListVersions2 = __esm(() => {
   init_promptsListVersions();
   init_operations();
   init_tools();
-  args89 = {
+  args90 = {
     request: ListPromptVersionsRequest$inboundSchema
   };
   tool$promptsListVersions = {
@@ -74911,9 +75472,9 @@ var init_promptsListVersions2 = __esm(() => {
     description: `List all prompt versions
 
 Returns a list of your prompt versions. The prompt versions are returned sorted by creation date, with the most recent prompt versions appearing first`,
-    args: args89,
-    tool: async (client, args90, ctx) => {
-      const [result, apiCall] = await promptsListVersions(client, args90.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args90,
+    tool: async (client, args91, ctx) => {
+      const [result, apiCall] = await promptsListVersions(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -74928,9 +75489,9 @@ Returns a list of your prompt versions. The prompt versions are returned sorted
 
 // src/funcs/promptsRetrieve.ts
 function promptsRetrieve(client, request, options) {
-  return new APIPromise($do91(client, request, options));
+  return new APIPromise($do92(client, request, options));
 }
-async function $do91(client, request, options) {
+async function $do92(client, request, options) {
   const parsed = safeParse(request, (value) => GetOnePromptRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75002,12 +75563,12 @@ var init_promptsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsRetrieve.ts
-var args90, tool$promptsRetrieve;
+var args91, tool$promptsRetrieve;
 var init_promptsRetrieve2 = __esm(() => {
   init_promptsRetrieve();
   init_operations();
   init_tools();
-  args90 = {
+  args91 = {
     request: GetOnePromptRequest$inboundSchema
   };
   tool$promptsRetrieve = {
@@ -75015,9 +75576,9 @@ var init_promptsRetrieve2 = __esm(() => {
     description: `Retrieve a prompt
 
 Retrieves a prompt object`,
-    args: args90,
-    tool: async (client, args91, ctx) => {
-      const [result, apiCall] = await promptsRetrieve(client, args91.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args91,
+    tool: async (client, args92, ctx) => {
+      const [result, apiCall] = await promptsRetrieve(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75032,9 +75593,9 @@ Retrieves a prompt object`,
 
 // src/funcs/promptsUpdate.ts
 function promptsUpdate(client, request, options) {
-  return new APIPromise($do92(client, request, options));
+  return new APIPromise($do93(client, request, options));
 }
-async function $do92(client, request, options) {
+async function $do93(client, request, options) {
   const parsed = safeParse(request, (value) => UpdatePromptRequest$outboundSchema.parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75111,20 +75672,20 @@ var init_promptsUpdate = __esm(() => {
 });
 
 // src/mcp-server/tools/promptsUpdate.ts
-var args91, tool$promptsUpdate;
+var args92, tool$promptsUpdate;
 var init_promptsUpdate2 = __esm(() => {
   init_promptsUpdate();
   init_operations();
   init_tools();
-  args91 = {
+  args92 = {
     request: UpdatePromptRequest$inboundSchema
   };
   tool$promptsUpdate = {
     name: "prompts-update",
     description: `Update a prompt`,
-    args: args91,
-    tool: async (client, args92, ctx) => {
-      const [result, apiCall] = await promptsUpdate(client, args92.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args92,
+    tool: async (client, args93, ctx) => {
+      const [result, apiCall] = await promptsUpdate(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75139,9 +75700,9 @@ var init_promptsUpdate2 = __esm(() => {
 
 // src/funcs/remoteconfigsRetrieve.ts
 function remoteconfigsRetrieve(client, request, options) {
-  return new APIPromise($do93(client, request, options));
+  return new APIPromise($do94(client, request, options));
 }
-async function $do93(client, request, options) {
+async function $do94(client, request, options) {
   const parsed = safeParse(request, (value) => RemoteConfigsGetConfigRequestBody$outboundSchema.optional().parse(value), "Input validation failed");
   if (!parsed.ok) {
     return [parsed, { status: "invalid" }];
@@ -75208,20 +75769,20 @@ var init_remoteconfigsRetrieve = __esm(() => {
 });
 
 // src/mcp-server/tools/remoteconfigsRetrieve.ts
-var args92, tool$remoteconfigsRetrieve;
+var args93, tool$remoteconfigsRetrieve;
 var init_remoteconfigsRetrieve2 = __esm(() => {
   init_remoteconfigsRetrieve();
   init_operations();
   init_tools();
-  args92 = {
+  args93 = {
     request: RemoteConfigsGetConfigRequestBody$inboundSchema.optional()
   };
   tool$remoteconfigsRetrieve = {
     name: "remoteconfigs-retrieve",
     description: `Retrieve a remote config`,
-    args: args92,
-    tool: async (client, args93, ctx) => {
-      const [result, apiCall] = await remoteconfigsRetrieve(client, args93.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
+    args: args93,
+    tool: async (client, args94, ctx) => {
+      const [result, apiCall] = await remoteconfigsRetrieve(client, args94.request, { fetchOptions: { signal: ctx.signal } }).$inspect();
       if (!result.ok) {
         return {
           content: [{ type: "text", text: result.error.message }],
@@ -75238,7 +75799,7 @@ var init_remoteconfigsRetrieve2 = __esm(() => {
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "Orq",
-    version: "3.9.6"
+    version: "3.9.7"
   });
   const client = new OrqCore({
     apiKey: deps.apiKey,
@@ -75304,6 +75865,7 @@ function createMCPServer(deps) {
   tool(tool$knowledgeUpdateChunk);
   tool(tool$knowledgeDeleteChunk);
   tool(tool$knowledgeRetrieveChunk);
+  tool(tool$chunkingParse);
   tool(tool$evalsAll);
   tool(tool$evalsCreate);
   tool(tool$evalsUpdate);
@@ -75354,6 +75916,7 @@ var init_server2 = __esm(() => {
   init_core();
   init_resources();
   init_tools();
+  init_chunkingParse2();
   init_contactsCreate2();
   init_contactsDelete2();
   init_contactsList2();
@@ -76644,7 +77207,7 @@ var routes = rn({
 var app = Ve(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "3.9.6"
+    currentVersion: "3.9.7"
   }
 });
 _t(app, process3.argv.slice(2), buildContext(process3));
@@ -76652,5 +77215,5 @@ export {
   app
 };
 
-//# debugId=6D9ED5BA45BA62E564756E2164756E21
+//# debugId=85312E0B52D28C7464756E2164756E21
 //# sourceMappingURL=mcp-server.js.map