syllable-sdk 1.0.13-rc.4 → 1.0.13-rc.6

package/bin/mcp-server.js

@@ -34419,9 +34419,9 @@ var init_config = __esm(() => {
   SDK_METADATA = {
     language: "typescript",
     openapiDocVersion: "0.0.2",
-    sdkVersion: "1.0.13-rc.4",
+    sdkVersion: "1.0.13-rc.6",
     genVersion: "2.760.2",
-    userAgent: "speakeasy-sdk/typescript 1.0.13-rc.4 2.760.2 0.0.2 syllable-sdk"
+    userAgent: "speakeasy-sdk/typescript 1.0.13-rc.6 2.760.2 0.0.2 syllable-sdk"
   };
 });
 
@@ -35934,27 +35934,6 @@ function safeParse(rawValue, fn, errorMessage) {
     return ERR(new SDKValidationError(errorMessage, err, rawValue));
   }
 }
-function collectExtraKeys(obj, extrasKey, optional2) {
-  return obj.transform((val) => {
-    const extras = {};
-    const { shape } = obj;
-    for (const [key] of Object.entries(val)) {
-      if (key in shape) {
-        continue;
-      }
-      const v2 = val[key];
-      if (typeof v2 === "undefined") {
-        continue;
-      }
-      extras[key] = v2;
-      delete val[key];
-    }
-    if (optional2 && Object.keys(extras).length === 0) {
-      return val;
-    }
-    return { ...val, [extrasKey]: extras };
-  });
-}
 var init_schemas = __esm(() => {
   init_sdkvalidationerror();
 });
@@ -36627,42 +36606,1978 @@ var init_toolagentinfo = __esm(() => {
   });
 });
 
-// src/models/components/contexttask.ts
-var ContextTask$inboundSchema, ContextTask$outboundSchema;
-var init_contexttask = __esm(() => {
+// src/models/components/contexttaskmetadata.ts
+var ContextTaskMetadata$inboundSchema, ContextTaskMetadata$outboundSchema;
+var init_contexttaskmetadata = __esm(() => {
   init_v3();
   init_primitives();
-  init_schemas();
-  ContextTask$inboundSchema = collectExtraKeys(objectType({
-    type: nullableType(stringType()).optional(),
-    id: nullableType(stringType()).optional()
-  }).catchall(anyType()), "additionalProperties", true);
-  ContextTask$outboundSchema = objectType({
-    type: nullableType(stringType()).optional(),
+  ContextTaskMetadata$inboundSchema = objectType({
+    priority: nullableType(numberType().int()).optional(),
+    parent_tool_name: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      parent_tool_name: "parentToolName"
+    });
+  });
+  ContextTaskMetadata$outboundSchema = objectType({
+    priority: nullableType(numberType().int()).optional(),
+    parentToolName: nullableType(stringType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      parentToolName: "parent_tool_name"
+    });
+  });
+});
+
+// src/models/components/contexttoolinfo.ts
+var ContextToolInfo$inboundSchema, ContextToolInfo$outboundSchema;
+var init_contexttoolinfo = __esm(() => {
+  init_v3();
+  ContextToolInfo$inboundSchema = objectType({
+    name: nullableType(stringType()).optional(),
+    description: nullableType(stringType()).optional()
+  });
+  ContextToolInfo$outboundSchema = objectType({
+    name: nullableType(stringType()).optional(),
+    description: nullableType(stringType()).optional()
+  });
+});
+
+// src/models/components/celexpression.ts
+var CelExpression$inboundSchema, CelExpression$outboundSchema;
+var init_celexpression = __esm(() => {
+  init_v3();
+  CelExpression$inboundSchema = objectType({
+    expression: stringType(),
+    type: literalType("cel").default("cel")
+  });
+  CelExpression$outboundSchema = objectType({
+    expression: stringType(),
+    type: literalType("cel").default("cel")
+  });
+});
+
+// src/models/components/jmespathexpression.ts
+var JMESPathExpressionType, JMESPathExpressionType$inboundSchema, JMESPathExpressionType$outboundSchema, JMESPathExpression$inboundSchema, JMESPathExpression$outboundSchema;
+var init_jmespathexpression = __esm(() => {
+  init_v3();
+  JMESPathExpressionType = {
+    Jp: "jp",
+    Jmespath: "jmespath"
+  };
+  JMESPathExpressionType$inboundSchema = nativeEnumType(JMESPathExpressionType);
+  JMESPathExpressionType$outboundSchema = JMESPathExpressionType$inboundSchema;
+  JMESPathExpression$inboundSchema = objectType({
+    expression: stringType(),
+    type: JMESPathExpressionType$inboundSchema.default("jp")
+  });
+  JMESPathExpression$outboundSchema = objectType({
+    expression: stringType(),
+    type: JMESPathExpressionType$outboundSchema.default("jp")
+  });
+});
+
+// src/models/components/conditionalvalue.ts
+var ValueFrom1$inboundSchema, ValueFrom1$outboundSchema, If1$inboundSchema, If1$outboundSchema, If$inboundSchema, If$outboundSchema, ConditionalValue$inboundSchema, ConditionalValue$outboundSchema, ValueFrom$inboundSchema, ValueFrom$outboundSchema;
+var init_conditionalvalue = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  ValueFrom1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  ValueFrom1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  If1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  If1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  If$inboundSchema = unionType([
+    lazyType(() => CaseExpression$inboundSchema),
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  If$outboundSchema = unionType([
+    lazyType(() => CaseExpression$outboundSchema),
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+        type: v2.type
+      })))
+    ]),
+    stringType()
+  ]);
+  ConditionalValue$inboundSchema = objectType({
+    value: nullableType(anyType()).optional(),
+    value_from: nullableType(unionType([
+      lazyType(() => CaseExpression$inboundSchema),
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    if: nullableType(unionType([
+      lazyType(() => CaseExpression$inboundSchema),
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      value_from: "valueFrom"
+    });
+  });
+  ConditionalValue$outboundSchema = objectType({
+    value: nullableType(anyType()).optional(),
+    valueFrom: nullableType(unionType([
+      lazyType(() => CaseExpression$outboundSchema),
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    if: nullableType(unionType([
+      lazyType(() => CaseExpression$outboundSchema),
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      valueFrom: "value_from"
+    });
+  });
+  ValueFrom$inboundSchema = unionType([
+    lazyType(() => CaseExpression$inboundSchema),
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  ValueFrom$outboundSchema = unionType([
+    lazyType(() => CaseExpression$outboundSchema),
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+});
+
+// src/models/components/caseexpression.ts
+var CaseExpression$inboundSchema, CaseExpression$outboundSchema;
+var init_caseexpression = __esm(() => {
+  init_v3();
+  init_conditionalvalue();
+  CaseExpression$inboundSchema = objectType({
+    case: arrayType(lazyType(() => ConditionalValue$inboundSchema))
+  });
+  CaseExpression$outboundSchema = objectType({
+    case: arrayType(lazyType(() => ConditionalValue$outboundSchema))
+  });
+});
+
+// src/models/components/callaction.ts
+var CallActionIf1$inboundSchema, CallActionIf1$outboundSchema, CallActionIf$inboundSchema, CallActionIf$outboundSchema, AutoPopulate$inboundSchema, AutoPopulate$outboundSchema, CallAction$inboundSchema, CallAction$outboundSchema;
+var init_callaction = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  CallActionIf1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  CallActionIf1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  CallActionIf$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  CallActionIf$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  AutoPopulate$inboundSchema = unionType([booleanType(), stringType()]);
+  AutoPopulate$outboundSchema = unionType([booleanType(), stringType()]);
+  CallAction$inboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("call").default("call"),
+    name: stringType(),
+    arguments: nullableType(recordType(anyType())).optional(),
+    auto_populate: unionType([booleanType(), stringType()]).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      auto_populate: "autoPopulate"
+    });
+  });
+  CallAction$outboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("call").default("call"),
+    name: stringType(),
+    arguments: nullableType(recordType(anyType())).optional(),
+    autoPopulate: unionType([booleanType(), stringType()]).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      autoPopulate: "auto_populate"
+    });
+  });
+});
+
+// src/models/components/incrementaction.ts
+var IncrementActionIf1$inboundSchema, IncrementActionIf1$outboundSchema, IncrementActionIf$inboundSchema, IncrementActionIf$outboundSchema, IncrementAction$inboundSchema, IncrementAction$outboundSchema;
+var init_incrementaction = __esm(() => {
+  init_v3();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  IncrementActionIf1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  IncrementActionIf1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  IncrementActionIf$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  IncrementActionIf$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  IncrementAction$inboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("inc").default("inc"),
+    name: stringType(),
+    by: numberType().int().default(1)
+  });
+  IncrementAction$outboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("inc").default("inc"),
+    name: stringType(),
+    by: numberType().int().default(1)
+  });
+});
+
+// src/models/components/saveaction.ts
+var SaveActionIf1$inboundSchema, SaveActionIf1$outboundSchema, SaveActionIf$inboundSchema, SaveActionIf$outboundSchema, SaveAction$inboundSchema, SaveAction$outboundSchema;
+var init_saveaction = __esm(() => {
+  init_v3();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  SaveActionIf1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SaveActionIf1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SaveActionIf$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  SaveActionIf$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  SaveAction$inboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("save").default("save"),
+    name: nullableType(stringType()).optional(),
+    inputs: nullableType(arrayType(stringType())).optional()
+  });
+  SaveAction$outboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("save").default("save"),
+    name: nullableType(stringType()).optional(),
+    inputs: nullableType(arrayType(stringType())).optional()
+  });
+});
+
+// src/models/components/sayaction.ts
+var Role, SayActionIf1$inboundSchema, SayActionIf1$outboundSchema, SayActionIf$inboundSchema, SayActionIf$outboundSchema, Role$inboundSchema, Role$outboundSchema, SayAction$inboundSchema, SayAction$outboundSchema;
+var init_sayaction = __esm(() => {
+  init_v3();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  Role = {
+    User: "user",
+    Assistant: "assistant"
+  };
+  SayActionIf1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SayActionIf1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SayActionIf$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  SayActionIf$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  Role$inboundSchema = nativeEnumType(Role);
+  Role$outboundSchema = Role$inboundSchema;
+  SayAction$inboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    text: stringType(),
+    action: literalType("say").default("say"),
+    role: Role$inboundSchema.default("assistant")
+  });
+  SayAction$outboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    text: stringType(),
+    action: literalType("say").default("say"),
+    role: Role$outboundSchema.default("assistant")
+  });
+});
+
+// src/models/components/setvalueaction.ts
+var SetValueActionValueFrom1$inboundSchema, SetValueActionValueFrom1$outboundSchema, SetValueActionValueFrom$inboundSchema, SetValueActionValueFrom$outboundSchema, SetValueActionIf1$inboundSchema, SetValueActionIf1$outboundSchema, SetValueActionIf$inboundSchema, SetValueActionIf$outboundSchema, SetValueAction$inboundSchema, SetValueAction$outboundSchema;
+var init_setvalueaction = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  SetValueActionValueFrom1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SetValueActionValueFrom1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SetValueActionValueFrom$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  SetValueActionValueFrom$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  SetValueActionIf1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SetValueActionIf1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  SetValueActionIf$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  SetValueActionIf$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  SetValueAction$inboundSchema = objectType({
+    value: nullableType(anyType()).optional(),
+    value_from: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    if: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("set").default("set"),
+    name: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      value_from: "valueFrom"
+    });
+  });
+  SetValueAction$outboundSchema = objectType({
+    value: nullableType(anyType()).optional(),
+    valueFrom: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    if: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    action: literalType("set").default("set"),
+    name: stringType()
+  }).transform((v2) => {
+    return remap(v2, {
+      valueFrom: "value_from"
+    });
+  });
+});
+
+// src/models/components/eventtaskevents.ts
+var EventTaskEventsStart$inboundSchema, EventTaskEventsStart$outboundSchema, EventTaskEvents$inboundSchema, EventTaskEvents$outboundSchema;
+var init_eventtaskevents = __esm(() => {
+  init_v3();
+  init_callaction();
+  init_incrementaction();
+  init_saveaction();
+  init_sayaction();
+  init_setvalueaction();
+  EventTaskEventsStart$inboundSchema = unionType([
+    CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  EventTaskEventsStart$outboundSchema = unionType([
+    CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  EventTaskEvents$inboundSchema = objectType({
+    start: nullableType(arrayType(unionType([
+      CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional()
+  });
+  EventTaskEvents$outboundSchema = objectType({
+    start: nullableType(arrayType(unionType([
+      CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional()
+  });
+});
+
+// src/models/components/variable.ts
+var VariableType, One$inboundSchema, One$outboundSchema, VariableValueFrom$inboundSchema, VariableValueFrom$outboundSchema, VariableType$inboundSchema, VariableType$outboundSchema, Variable$inboundSchema, Variable$outboundSchema;
+var init_variable = __esm(() => {
+  init_v3();
+  init_primitives();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  VariableType = {
+    String: "string",
+    Number: "number",
+    Integer: "integer",
+    Boolean: "boolean",
+    Object: "object",
+    Array: "array",
+    Null: "null"
+  };
+  One$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  One$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  VariableValueFrom$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  VariableValueFrom$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  VariableType$inboundSchema = nativeEnumType(VariableType);
+  VariableType$outboundSchema = VariableType$inboundSchema;
+  Variable$inboundSchema = objectType({
+    value: nullableType(anyType()).optional(),
+    value_from: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    name: stringType(),
+    type: nullableType(VariableType$inboundSchema).optional(),
+    description: nullableType(stringType()).optional(),
+    title: nullableType(stringType()).optional(),
+    format: nullableType(stringType()).optional(),
+    pattern: nullableType(stringType()).optional(),
+    enum: nullableType(arrayType(stringType())).optional(),
+    examples: nullableType(arrayType(anyType())).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      value_from: "valueFrom"
+    });
+  });
+  Variable$outboundSchema = objectType({
+    value: nullableType(anyType()).optional(),
+    valueFrom: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    name: stringType(),
+    type: nullableType(VariableType$outboundSchema).optional(),
+    description: nullableType(stringType()).optional(),
+    title: nullableType(stringType()).optional(),
+    format: nullableType(stringType()).optional(),
+    pattern: nullableType(stringType()).optional(),
+    enum: nullableType(arrayType(stringType())).optional(),
+    examples: nullableType(arrayType(anyType())).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      valueFrom: "value_from"
+    });
+  });
+});
+
+// src/models/components/eventtask.ts
+var EventTask$inboundSchema, EventTask$outboundSchema;
+var init_eventtask = __esm(() => {
+  init_v3();
+  init_contexttaskmetadata();
+  init_contexttoolinfo();
+  init_eventtaskevents();
+  init_variable();
+  EventTask$inboundSchema = objectType({
+    id: nullableType(stringType()).optional(),
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$inboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$inboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$inboundSchema).optional(),
+    type: literalType("event").default("event"),
+    version: literalType("v1alpha").default("v1alpha"),
+    on: EventTaskEvents$inboundSchema.optional()
+  });
+  EventTask$outboundSchema = objectType({
     id: nullableType(stringType()).optional(),
-    additionalProperties: recordType(anyType()).optional()
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$outboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$outboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$outboundSchema).optional(),
+    type: literalType("event").default("event"),
+    version: literalType("v1alpha").default("v1alpha"),
+    on: EventTaskEvents$outboundSchema.optional()
+  });
+});
+
+// src/models/components/expressiontaskevents.ts
+var Start$inboundSchema, Start$outboundSchema, Submit$inboundSchema, Submit$outboundSchema, ExpressionTaskEvents$inboundSchema, ExpressionTaskEvents$outboundSchema;
+var init_expressiontaskevents = __esm(() => {
+  init_v3();
+  init_callaction();
+  init_incrementaction();
+  init_saveaction();
+  init_sayaction();
+  init_setvalueaction();
+  Start$inboundSchema = unionType([
+    CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  Start$outboundSchema = unionType([
+    CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  Submit$inboundSchema = unionType([
+    CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  Submit$outboundSchema = unionType([
+    CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  ExpressionTaskEvents$inboundSchema = objectType({
+    start: nullableType(arrayType(unionType([
+      CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional(),
+    submit: nullableType(arrayType(unionType([
+      CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional()
+  });
+  ExpressionTaskEvents$outboundSchema = objectType({
+    start: nullableType(arrayType(unionType([
+      CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional(),
+    submit: nullableType(arrayType(unionType([
+      CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional()
+  });
+});
+
+// src/models/components/inputparameter.ts
+var InputParameterType, InputParameterType$inboundSchema, InputParameterType$outboundSchema, InputParameter$inboundSchema, InputParameter$outboundSchema;
+var init_inputparameter = __esm(() => {
+  init_v3();
+  InputParameterType = {
+    String: "string",
+    Number: "number",
+    Integer: "integer",
+    Boolean: "boolean",
+    Object: "object",
+    Array: "array",
+    Null: "null"
+  };
+  InputParameterType$inboundSchema = nativeEnumType(InputParameterType);
+  InputParameterType$outboundSchema = InputParameterType$inboundSchema;
+  InputParameter$inboundSchema = objectType({
+    name: stringType(),
+    type: nullableType(InputParameterType$inboundSchema).optional(),
+    description: nullableType(stringType()).optional(),
+    title: nullableType(stringType()).optional(),
+    format: nullableType(stringType()).optional(),
+    pattern: nullableType(stringType()).optional(),
+    enum: nullableType(arrayType(stringType())).optional(),
+    examples: nullableType(arrayType(anyType())).optional(),
+    required: booleanType().default(true)
+  });
+  InputParameter$outboundSchema = objectType({
+    name: stringType(),
+    type: nullableType(InputParameterType$outboundSchema).optional(),
+    description: nullableType(stringType()).optional(),
+    title: nullableType(stringType()).optional(),
+    format: nullableType(stringType()).optional(),
+    pattern: nullableType(stringType()).optional(),
+    enum: nullableType(arrayType(stringType())).optional(),
+    examples: nullableType(arrayType(anyType())).optional(),
+    required: booleanType().default(true)
+  });
+});
+
+// src/models/components/expressiontask.ts
+var Expression1$inboundSchema, Expression1$outboundSchema, Expression$inboundSchema, Expression$outboundSchema, ExpressionTask$inboundSchema, ExpressionTask$outboundSchema;
+var init_expressiontask = __esm(() => {
+  init_v3();
+  init_caseexpression();
+  init_celexpression();
+  init_contexttaskmetadata();
+  init_contexttoolinfo();
+  init_expressiontaskevents();
+  init_inputparameter();
+  init_jmespathexpression();
+  init_variable();
+  Expression1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  Expression1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  Expression$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  Expression$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  ExpressionTask$inboundSchema = objectType({
+    id: nullableType(stringType()).optional(),
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$inboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$inboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$inboundSchema).optional(),
+    type: literalType("expression").default("expression"),
+    version: literalType("v1alpha").default("v1alpha"),
+    inputs: arrayType(InputParameter$inboundSchema).optional(),
+    expression: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    output: nullableType(anyType()).optional(),
+    on: ExpressionTaskEvents$inboundSchema.optional()
+  });
+  ExpressionTask$outboundSchema = objectType({
+    id: nullableType(stringType()).optional(),
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$outboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$outboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$outboundSchema).optional(),
+    type: literalType("expression").default("expression"),
+    version: literalType("v1alpha").default("v1alpha"),
+    inputs: arrayType(InputParameter$outboundSchema).optional(),
+    expression: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    output: nullableType(anyType()).optional(),
+    on: ExpressionTaskEvents$outboundSchema.optional()
+  });
+});
+
+// src/models/components/loadtoolfromfiletask.ts
+var FileT$inboundSchema, FileT$outboundSchema, LoadToolFromFileTask$inboundSchema, LoadToolFromFileTask$outboundSchema;
+var init_loadtoolfromfiletask = __esm(() => {
+  init_v3();
+  init_contexttaskmetadata();
+  init_contexttoolinfo();
+  init_variable();
+  FileT$inboundSchema = unionType([stringType(), arrayType(stringType())]);
+  FileT$outboundSchema = unionType([stringType(), arrayType(stringType())]);
+  LoadToolFromFileTask$inboundSchema = objectType({
+    id: nullableType(stringType()).optional(),
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$inboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$inboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$inboundSchema).optional(),
+    type: literalType("import").default("import"),
+    version: literalType("v1alpha").default("v1alpha"),
+    file: unionType([stringType(), arrayType(stringType())])
+  });
+  LoadToolFromFileTask$outboundSchema = objectType({
+    id: nullableType(stringType()).optional(),
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$outboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$outboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$outboundSchema).optional(),
+    type: literalType("import").default("import"),
+    version: literalType("v1alpha").default("v1alpha"),
+    file: unionType([stringType(), arrayType(stringType())])
+  });
+});
+
+// src/models/components/conditionaltext.ts
+var ConditionalTextIf1$inboundSchema, ConditionalTextIf1$outboundSchema, ConditionalTextIf$inboundSchema, ConditionalTextIf$outboundSchema, ConditionalText$inboundSchema, ConditionalText$outboundSchema;
+var init_conditionaltext = __esm(() => {
+  init_v3();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  ConditionalTextIf1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  ConditionalTextIf1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  ConditionalTextIf$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  ConditionalTextIf$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  ConditionalText$inboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    text: stringType()
+  });
+  ConditionalText$outboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    text: stringType()
+  });
+});
+
+// src/models/components/nextstep.ts
+var NextStepIf1$inboundSchema, NextStepIf1$outboundSchema, NextStepIf$inboundSchema, NextStepIf$outboundSchema, NextStep$inboundSchema, NextStep$outboundSchema;
+var init_nextstep = __esm(() => {
+  init_v3();
+  init_caseexpression();
+  init_celexpression();
+  init_jmespathexpression();
+  NextStepIf1$inboundSchema = unionType([
+    CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  NextStepIf1$outboundSchema = unionType([
+    CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  NextStepIf$inboundSchema = unionType([
+    CaseExpression$inboundSchema,
+    unionType([
+      CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  NextStepIf$outboundSchema = unionType([
+    CaseExpression$outboundSchema,
+    unionType([
+      CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({ type: v2.type }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({ type: v2.type })))
+    ]),
+    stringType()
+  ]);
+  NextStep$inboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$inboundSchema,
+      unionType([
+        CelExpression$inboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$inboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    id: stringType(),
+    requires: nullableType(arrayType(stringType())).optional()
+  });
+  NextStep$outboundSchema = objectType({
+    if: nullableType(unionType([
+      CaseExpression$outboundSchema,
+      unionType([
+        CelExpression$outboundSchema.and(objectType({ type: literalType("cel") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jmespath") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        JMESPathExpression$outboundSchema.and(objectType({ type: literalType("jp") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      stringType()
+    ])).optional(),
+    id: stringType(),
+    requires: nullableType(arrayType(stringType())).optional()
+  });
+});
+
+// src/models/components/stepeventactions.ts
+var StepEventActionsStart$inboundSchema, StepEventActionsStart$outboundSchema, Enter$inboundSchema, Enter$outboundSchema, StepEventActionsSubmit$inboundSchema, StepEventActionsSubmit$outboundSchema, StepEventActions$inboundSchema, StepEventActions$outboundSchema;
+var init_stepeventactions = __esm(() => {
+  init_v3();
+  init_callaction();
+  init_incrementaction();
+  init_saveaction();
+  init_sayaction();
+  init_setvalueaction();
+  StepEventActionsStart$inboundSchema = unionType([
+    CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  StepEventActionsStart$outboundSchema = unionType([
+    CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  Enter$inboundSchema = unionType([
+    CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  Enter$outboundSchema = unionType([
+    CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  StepEventActionsSubmit$inboundSchema = unionType([
+    CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  StepEventActionsSubmit$outboundSchema = unionType([
+    CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+      action: v2.action
+    }))),
+    SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+      action: v2.action
+    })))
+  ]);
+  StepEventActions$inboundSchema = objectType({
+    start: nullableType(arrayType(unionType([
+      CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional(),
+    enter: nullableType(arrayType(unionType([
+      CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional(),
+    submit: nullableType(arrayType(unionType([
+      CallAction$inboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$inboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$inboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$inboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$inboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional()
+  });
+  StepEventActions$outboundSchema = objectType({
+    start: nullableType(arrayType(unionType([
+      CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional(),
+    enter: nullableType(arrayType(unionType([
+      CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional(),
+    submit: nullableType(arrayType(unionType([
+      CallAction$outboundSchema.and(objectType({ action: literalType("call") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      IncrementAction$outboundSchema.and(objectType({ action: literalType("inc") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SayAction$outboundSchema.and(objectType({ action: literalType("say") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SetValueAction$outboundSchema.and(objectType({ action: literalType("set") }).transform((v2) => ({
+        action: v2.action
+      }))),
+      SaveAction$outboundSchema.and(objectType({ action: literalType("save") }).transform((v2) => ({
+        action: v2.action
+      })))
+    ]))).optional()
+  });
+});
+
+// src/models/components/steptools.ts
+var StepTools$inboundSchema, StepTools$outboundSchema;
+var init_steptools = __esm(() => {
+  init_v3();
+  init_primitives();
+  StepTools$inboundSchema = objectType({
+    call: nullableType(booleanType()).optional(),
+    allow: nullableType(arrayType(stringType())).optional(),
+    allow_go_to_step: nullableType(booleanType()).optional()
   }).transform((v2) => {
-    return {
-      ...v2.additionalProperties,
-      ...remap(v2, {
-        additionalProperties: null
-      })
-    };
+    return remap(v2, {
+      allow_go_to_step: "allowGoToStep"
+    });
+  });
+  StepTools$outboundSchema = objectType({
+    call: nullableType(booleanType()).optional(),
+    allow: nullableType(arrayType(stringType())).optional(),
+    allowGoToStep: nullableType(booleanType()).optional()
+  }).transform((v2) => {
+    return remap(v2, {
+      allowGoToStep: "allow_go_to_step"
+    });
+  });
+});
+
+// src/models/components/step.ts
+var Instructions$inboundSchema, Instructions$outboundSchema, Next$inboundSchema, Next$outboundSchema, Step$inboundSchema, Step$outboundSchema;
+var init_step = __esm(() => {
+  init_v3();
+  init_conditionaltext();
+  init_inputparameter();
+  init_nextstep();
+  init_stepeventactions();
+  init_steptools();
+  Instructions$inboundSchema = unionType([ConditionalText$inboundSchema, stringType()]);
+  Instructions$outboundSchema = unionType([ConditionalText$outboundSchema, stringType()]);
+  Next$inboundSchema = unionType([NextStep$inboundSchema, stringType()]);
+  Next$outboundSchema = unionType([NextStep$outboundSchema, stringType()]);
+  Step$inboundSchema = objectType({
+    id: stringType(),
+    goal: stringType(),
+    instructions: arrayType(unionType([ConditionalText$inboundSchema, stringType()])).optional(),
+    tools: StepTools$inboundSchema.optional(),
+    inputs: arrayType(InputParameter$inboundSchema).optional(),
+    on: StepEventActions$inboundSchema.optional(),
+    next: arrayType(unionType([NextStep$inboundSchema, stringType()])).optional()
+  });
+  Step$outboundSchema = objectType({
+    id: stringType(),
+    goal: stringType(),
+    instructions: arrayType(unionType([ConditionalText$outboundSchema, stringType()])).optional(),
+    tools: StepTools$outboundSchema.optional(),
+    inputs: arrayType(InputParameter$outboundSchema).optional(),
+    on: StepEventActions$outboundSchema.optional(),
+    next: arrayType(unionType([NextStep$outboundSchema, stringType()])).optional()
+  });
+});
+
+// src/models/components/stepstask.ts
+var StepsTask$inboundSchema, StepsTask$outboundSchema;
+var init_stepstask = __esm(() => {
+  init_v3();
+  init_contexttaskmetadata();
+  init_contexttoolinfo();
+  init_step();
+  init_variable();
+  StepsTask$inboundSchema = objectType({
+    id: nullableType(stringType()).optional(),
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$inboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$inboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$inboundSchema).optional(),
+    type: literalType("steps").default("steps"),
+    version: literalType("v1alpha").default("v1alpha"),
+    steps: arrayType(Step$inboundSchema).optional()
+  });
+  StepsTask$outboundSchema = objectType({
+    id: nullableType(stringType()).optional(),
+    config: nullableType(recordType(anyType())).optional(),
+    variables: nullableType(arrayType(Variable$outboundSchema)).optional(),
+    metadata: nullableType(ContextTaskMetadata$outboundSchema).optional(),
+    tool: nullableType(ContextToolInfo$outboundSchema).optional(),
+    type: literalType("steps").default("steps"),
+    version: literalType("v1alpha").default("v1alpha"),
+    steps: arrayType(Step$outboundSchema).optional()
   });
 });
 
 // src/models/components/context.ts
-var Task$inboundSchema, Task$outboundSchema, Context$inboundSchema, Context$outboundSchema;
+var Two$inboundSchema, Two$outboundSchema, Task1$inboundSchema, Task1$outboundSchema, Task$inboundSchema, Task$outboundSchema, Context$inboundSchema, Context$outboundSchema;
 var init_context = __esm(() => {
   init_v3();
-  init_contexttask();
-  Task$inboundSchema = unionType([ContextTask$inboundSchema, arrayType(ContextTask$inboundSchema)]);
-  Task$outboundSchema = unionType([ContextTask$outboundSchema, arrayType(ContextTask$outboundSchema)]);
+  init_eventtask();
+  init_expressiontask();
+  init_loadtoolfromfiletask();
+  init_stepstask();
+  Two$inboundSchema = unionType([
+    LoadToolFromFileTask$inboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    EventTask$inboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    ExpressionTask$inboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    StepsTask$inboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+      type: v2.type
+    })))
+  ]);
+  Two$outboundSchema = unionType([
+    LoadToolFromFileTask$outboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    EventTask$outboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    ExpressionTask$outboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    StepsTask$outboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+      type: v2.type
+    })))
+  ]);
+  Task1$inboundSchema = unionType([
+    LoadToolFromFileTask$inboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    EventTask$inboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    ExpressionTask$inboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    StepsTask$inboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+      type: v2.type
+    })))
+  ]);
+  Task1$outboundSchema = unionType([
+    LoadToolFromFileTask$outboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    EventTask$outboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({ type: v2.type }))),
+    ExpressionTask$outboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+      type: v2.type
+    }))),
+    StepsTask$outboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({ type: v2.type })))
+  ]);
+  Task$inboundSchema = unionType([
+    unionType([
+      LoadToolFromFileTask$inboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      EventTask$inboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      ExpressionTask$inboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      StepsTask$inboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+        type: v2.type
+      })))
+    ]),
+    arrayType(unionType([
+      LoadToolFromFileTask$inboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      EventTask$inboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      ExpressionTask$inboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      StepsTask$inboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+        type: v2.type
+      })))
+    ]))
+  ]);
+  Task$outboundSchema = unionType([
+    unionType([
+      LoadToolFromFileTask$outboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      EventTask$outboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      ExpressionTask$outboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      StepsTask$outboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+        type: v2.type
+      })))
+    ]),
+    arrayType(unionType([
+      LoadToolFromFileTask$outboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      EventTask$outboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      ExpressionTask$outboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+        type: v2.type
+      }))),
+      StepsTask$outboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+        type: v2.type
+      })))
+    ]))
+  ]);
   Context$inboundSchema = objectType({
-    task: nullableType(unionType([ContextTask$inboundSchema, arrayType(ContextTask$inboundSchema)])).optional()
+    task: nullableType(unionType([
+      unionType([
+        LoadToolFromFileTask$inboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        EventTask$inboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        ExpressionTask$inboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        StepsTask$inboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      arrayType(unionType([
+        LoadToolFromFileTask$inboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        EventTask$inboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        ExpressionTask$inboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        StepsTask$inboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]))
+    ])).optional()
   });
   Context$outboundSchema = objectType({
-    task: nullableType(unionType([ContextTask$outboundSchema, arrayType(ContextTask$outboundSchema)])).optional()
+    task: nullableType(unionType([
+      unionType([
+        LoadToolFromFileTask$outboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        EventTask$outboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        ExpressionTask$outboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        StepsTask$outboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]),
+      arrayType(unionType([
+        LoadToolFromFileTask$outboundSchema.and(objectType({ type: literalType("import") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        EventTask$outboundSchema.and(objectType({ type: literalType("event") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        ExpressionTask$outboundSchema.and(objectType({ type: literalType("expression") }).transform((v2) => ({
+          type: v2.type
+        }))),
+        StepsTask$outboundSchema.and(objectType({ type: literalType("steps") }).transform((v2) => ({
+          type: v2.type
+        })))
+      ]))
+    ])).optional()
   });
 });
 
@@ -37744,11 +39659,11 @@ var init_bodydirectorymemberbulkload = __esm(() => {
 });
 
 // src/models/components/bodyinsightsfolderuploadfile.ts
-var FileT$inboundSchema, FileT$outboundSchema, BodyInsightsFolderUploadFile$inboundSchema, BodyInsightsFolderUploadFile$outboundSchema;
+var BodyInsightsFolderUploadFileFile$inboundSchema, BodyInsightsFolderUploadFileFile$outboundSchema, BodyInsightsFolderUploadFile$inboundSchema, BodyInsightsFolderUploadFile$outboundSchema;
 var init_bodyinsightsfolderuploadfile = __esm(() => {
   init_v3();
   init_blobs();
-  FileT$inboundSchema = objectType({
+  BodyInsightsFolderUploadFileFile$inboundSchema = objectType({
     fileName: stringType(),
     content: unionType([
       instanceOfType(ReadableStream),
@@ -37757,7 +39672,7 @@ var init_bodyinsightsfolderuploadfile = __esm(() => {
       instanceOfType(Uint8Array)
     ])
   });
-  FileT$outboundSchema = objectType({
+  BodyInsightsFolderUploadFileFile$outboundSchema = objectType({
     fileName: stringType(),
     content: unionType([
       instanceOfType(ReadableStream),
@@ -37767,10 +39682,10 @@ var init_bodyinsightsfolderuploadfile = __esm(() => {
     ])
   });
   BodyInsightsFolderUploadFile$inboundSchema = objectType({
-    file: lazyType(() => FileT$inboundSchema).optional()
+    file: lazyType(() => BodyInsightsFolderUploadFileFile$inboundSchema).optional()
   });
   BodyInsightsFolderUploadFile$outboundSchema = objectType({
-    file: lazyType(() => FileT$outboundSchema).or(blobLikeSchema).optional()
+    file: lazyType(() => BodyInsightsFolderUploadFileFile$outboundSchema).or(blobLikeSchema).optional()
   });
 });
 
@@ -41411,7 +43326,8 @@ var init_session = __esm(() => {
     source: nullableType(stringType()).optional(),
     target: nullableType(stringType()).optional(),
     is_legacy: nullableType(booleanType()).optional(),
-    is_test: nullableType(booleanType()).optional()
+    is_test: nullableType(booleanType()).optional(),
+    user_terminated: nullableType(booleanType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       session_id: "sessionId",
@@ -41429,7 +43345,8 @@ var init_session = __esm(() => {
       prompt_version_number: "promptVersionNumber",
       session_label_id: "sessionLabelId",
       is_legacy: "isLegacy",
-      is_test: "isTest"
+      is_test: "isTest",
+      user_terminated: "userTerminated"
     });
   });
   Session$outboundSchema = objectType({
@@ -41452,7 +43369,8 @@ var init_session = __esm(() => {
     source: nullableType(stringType()).optional(),
     target: nullableType(stringType()).optional(),
     isLegacy: nullableType(booleanType()).optional(),
-    isTest: nullableType(booleanType()).optional()
+    isTest: nullableType(booleanType()).optional(),
+    userTerminated: nullableType(booleanType()).optional()
   }).transform((v2) => {
     return remap(v2, {
       sessionId: "session_id",
@@ -41470,7 +43388,8 @@ var init_session = __esm(() => {
       promptVersionNumber: "prompt_version_number",
       sessionLabelId: "session_label_id",
       isLegacy: "is_legacy",
-      isTest: "is_test"
+      isTest: "is_test",
+      userTerminated: "user_terminated"
     });
   });
 });
@@ -43681,7 +45600,10 @@ var init_components = __esm(() => {
   init_bodyoutboundbatchdelete();
   init_bodyoutboundbatchupload();
   init_bodypronunciationsuploadcsv();
+  init_callaction();
   init_campaignproperties();
+  init_caseexpression();
+  init_celexpression();
   init_channel();
   init_channelconfigview();
   init_channelproperties();
@@ -43695,8 +45617,11 @@ var init_components = __esm(() => {
   init_communicationbatchupdate();
   init_communicationrequest();
   init_communicationrequestresult();
+  init_conditionaltext();
+  init_conditionalvalue();
   init_context();
-  init_contexttask();
+  init_contexttaskmetadata();
+  init_contexttoolinfo();
   init_conversation();
   init_conversationproperties();
   init_createtakeoutresponse();
@@ -43730,12 +45655,18 @@ var init_components = __esm(() => {
   init_directorymemberupdate();
   init_event();
   init_eventproperties();
+  init_eventtask();
+  init_eventtaskevents();
+  init_expressiontask();
+  init_expressiontaskevents();
   init_folderdetails();
   init_incidentcreaterequest();
   init_incidentorganizationresponse();
   init_incidentproperties();
   init_incidentresponse();
   init_incidentupdaterequest();
+  init_incrementaction();
+  init_inputparameter();
   init_insightsfolder();
   init_insightsfolderfilemove();
   init_insightsfolderinput();
@@ -43758,6 +45689,7 @@ var init_components = __esm(() => {
   init_insightworkflowproperties();
   init_inspectlatencyresponse();
   init_internaltool();
+  init_jmespathexpression();
   init_languagecode();
   init_languageconfig();
   init_languagegroupagentinfo();
@@ -43796,8 +45728,10 @@ var init_components = __esm(() => {
   init_listresponsetoolresponse();
   init_listresponseuserresponse();
   init_listresponsevoicegroupresponse();
+  init_loadtoolfromfiletask();
   init_logintype();
   init_matchtype();
+  init_nextstep();
   init_orderbydirection();
   init_organizationchannelconfig();
   init_organizationchannelcreaterequest();
@@ -43823,6 +45757,8 @@ var init_components = __esm(() => {
   init_roleproperties();
   init_roleresponse();
   init_roleupdaterequest();
+  init_saveaction();
+  init_sayaction();
   init_security2();
   init_servicecreaterequest();
   init_serviceproperties();
@@ -43840,8 +45776,13 @@ var init_components = __esm(() => {
   init_sessionsummaryresponse();
   init_sessiontext();
   init_sessiontranscriptionresponse();
+  init_setvalueaction();
   init_statictoolparameter();
   init_statictoolparametertype();
+  init_step();
+  init_stepeventactions();
+  init_stepstask();
+  init_steptools();
   init_summaryentry();
   init_supportedllm();
   init_takeoutrequeststatus();
@@ -43886,6 +45827,7 @@ var init_components = __esm(() => {
   init_userresponse();
   init_userupdaterequest();
   init_validationerror();
+  init_variable();
   init_voicedisplayinfo();
   init_voicegroupcreaterequest();
   init_voicegroupproperties();
@@ -64055,7 +65997,7 @@ Generate voice sample.`,
 function createMCPServer(deps) {
   const server = new McpServer({
     name: "SyllableSDK",
-    version: "1.0.13-rc.4"
+    version: "1.0.13-rc.6"
   });
   const client = new SyllableSDKCore({
     apiKeyHeader: deps.apiKeyHeader,
@@ -65589,7 +67531,7 @@ var routes = ln({
 var app = _e(routes, {
   name: "mcp",
   versionInfo: {
-    currentVersion: "1.0.13-rc.4"
+    currentVersion: "1.0.13-rc.6"
   }
 });
 Yt(app, process3.argv.slice(2), buildContext(process3));
@@ -65597,5 +67539,5 @@ export {
   app
 };
 
-//# debugId=48E9E2259031AC8164756E2164756E21
+//# debugId=404D69B5DD3853AC64756E2164756E21
 //# sourceMappingURL=mcp-server.js.map