@skaile/workspaces 2.3.0 → 2.5.0

package/dist/{chunk-ZE2KEPE2.js → chunk-OEGHKO5N.js}

@@ -8,6 +8,15 @@ var FLOW_EXPRESSION_LIMITS = Object.freeze({
   maxPathSegments: 32,
   maxCollectionItems: 1024
 });
+var FLOW_BINDING_NAME_PATTERN = /^(?!__proto__$)/;
+function collectFlowBindingExpressions(value) {
+  if (typeof value === "string") {
+    return Array.from(value.matchAll(/\$\{([^{}]+)\}/g), (match) => match[1]);
+  }
+  if (Array.isArray(value)) return value.flatMap(collectFlowBindingExpressions);
+  if (typeof value !== "object" || value === null) return [];
+  return Object.values(value).flatMap(collectFlowBindingExpressions);
+}
 var FlowExpressionError = class extends Error {
   /** Stable error name for callers that classify evaluator failures. */
   name = "FlowExpressionError";
@@ -201,16 +210,18 @@ function assertBooleanOperand(value, position) {
   if (!isBooleanOperand(value)) throw expressionError("requires boolean operands", position);
 }
 var Parser = class {
-  constructor(tokens, context, onPath, onBooleanPath) {
+  constructor(tokens, context, onPath, onBooleanPath, onEvaluatedPath) {
     this.tokens = tokens;
     this.context = context;
     this.onPath = onPath;
     this.onBooleanPath = onBooleanPath;
+    this.onEvaluatedPath = onEvaluatedPath;
   }
   tokens;
   context;
   onPath;
   onBooleanPath;
+  onEvaluatedPath;
   index = 0;
   nesting = 0;
   parse(evaluate2 = true) {
@@ -288,6 +299,7 @@ var Parser = class {
     if (token.kind === "word") {
       this.onPath?.(String(token.value));
       resolvePath(String(token.value), this.context, token.position, false);
+      if (evaluate2) this.onEvaluatedPath?.(String(token.value));
       return evaluate2 ? resolvePath(String(token.value), this.context, token.position, true) : { marker: STATIC_PATH, path: String(token.value) };
     }
     if (token.value === "(") {
@@ -354,8 +366,200 @@ function evaluateFlowExpression(expression, context) {
 function evaluate(expression, context) {
   return evaluateFlowExpression(expression, context);
 }
+function evaluateFlowExpressionValue(expression, context) {
+  const tokens = tokenize(expression);
+  if (expression.trim() === "default") return { value: true, paths: [] };
+  const paths = [];
+  const value = new Parser(
+    tokens,
+    context,
+    void 0,
+    void 0,
+    (path) => paths.push(path)
+  ).parse();
+  return { value, paths };
+}
+function originsForPath(path, nodeOutputOrigin, flowInputOrigins) {
+  if (path.startsWith("flow.input.")) {
+    const inputName = path.split(".")[2];
+    const inherited = flowInputOrigins[inputName];
+    return inherited ?? [{ source: "flow-input", path, obtainedBy: "runtime" }];
+  }
+  if (path.startsWith("defaults.")) {
+    return [{ source: "default", path, obtainedBy: "runtime" }];
+  }
+  const segments = path.split(".");
+  const nodeId = segments[1];
+  if (segments.length === 3 && segments[0] === "nodes" && segments[2] === "status") {
+    return [{ source: "node-status", nodeId, path, obtainedBy: "runtime" }];
+  }
+  if (segments.length >= 5 && segments[0] === "nodes" && segments[2] === "output" && segments[3] === "fields") {
+    const obtainedBy = nodeOutputOrigin[nodeId];
+    if (!obtainedBy) {
+      throw expressionError(`has no output origin for node ${nodeId}`);
+    }
+    return [{ source: "node-output", nodeId, path, obtainedBy }];
+  }
+  throw expressionError(`contains unsupported path ${path}`);
+}
+function stableFlowJson(value) {
+  if (value === void 0) return "null";
+  if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+  if (Array.isArray(value)) return `[${value.map(stableFlowJson).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).sort().map((key) => `${JSON.stringify(key)}:${stableFlowJson(object[key])}`).join(",")}}`;
+}
+function interpolationText(value) {
+  if (typeof value === "string") return value;
+  return stableFlowJson(value);
+}
+function deduplicateOrigins(origins) {
+  const seen = /* @__PURE__ */ new Set();
+  return origins.filter((origin) => {
+    const key = JSON.stringify(origin);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function resolveBindingValue(authored, bindingPath, context, nodeOutputOrigin, flowInputOrigins, depth) {
+  if (depth > FLOW_EXPRESSION_LIMITS.maxNesting) {
+    throw expressionError(`exceeds the nesting limit of ${FLOW_EXPRESSION_LIMITS.maxNesting}`);
+  }
+  if (typeof authored === "string") {
+    const exact = authored.match(/^\$\{([^{}]+)\}$/);
+    if (exact) {
+      const evaluated = evaluateFlowExpressionValue(exact[1], context);
+      return {
+        value: evaluated.value,
+        origins: deduplicateOrigins(
+          evaluated.paths.flatMap(
+            (path) => originsForPath(path, nodeOutputOrigin, flowInputOrigins)
+          )
+        )
+      };
+    }
+    const matches = Array.from(authored.matchAll(/\$\{([^{}]+)\}/g));
+    if (matches.length === 0) {
+      return {
+        value: authored,
+        origins: [{ source: "literal", path: bindingPath, obtainedBy: "runtime" }]
+      };
+    }
+    const origins = [
+      { source: "literal", path: bindingPath, obtainedBy: "runtime" }
+    ];
+    const value = authored.replace(/\$\{([^{}]+)\}/g, (_placeholder, expression) => {
+      const evaluated = evaluateFlowExpressionValue(expression, context);
+      origins.push(
+        ...evaluated.paths.flatMap(
+          (path) => originsForPath(path, nodeOutputOrigin, flowInputOrigins)
+        )
+      );
+      return interpolationText(evaluated.value);
+    });
+    return { value, origins: deduplicateOrigins(origins) };
+  }
+  if (Array.isArray(authored)) {
+    if (authored.length > FLOW_EXPRESSION_LIMITS.maxCollectionItems) {
+      throw expressionError(
+        `exceeds the collection item limit of ${FLOW_EXPRESSION_LIMITS.maxCollectionItems}`
+      );
+    }
+    const resolved = authored.map(
+      (value) => resolveBindingValue(
+        value,
+        bindingPath,
+        context,
+        nodeOutputOrigin,
+        flowInputOrigins,
+        depth + 1
+      )
+    );
+    return {
+      value: resolved.map(({ value }) => value),
+      origins: deduplicateOrigins([
+        { source: "literal", path: bindingPath, obtainedBy: "runtime" },
+        ...resolved.flatMap(({ origins }) => origins)
+      ])
+    };
+  }
+  if (typeof authored === "object" && authored !== null) {
+    const entries = Object.entries(authored);
+    if (entries.length > FLOW_EXPRESSION_LIMITS.maxCollectionItems) {
+      throw expressionError(
+        `exceeds the collection item limit of ${FLOW_EXPRESSION_LIMITS.maxCollectionItems}`
+      );
+    }
+    const resolved = entries.map(
+      ([key, value]) => [
+        key,
+        resolveBindingValue(
+          value,
+          bindingPath,
+          context,
+          nodeOutputOrigin,
+          flowInputOrigins,
+          depth + 1
+        )
+      ]
+    );
+    return {
+      value: Object.fromEntries(resolved.map(([key, result]) => [key, result.value])),
+      origins: deduplicateOrigins([
+        { source: "literal", path: bindingPath, obtainedBy: "runtime" },
+        ...resolved.flatMap(([, result]) => result.origins)
+      ])
+    };
+  }
+  return {
+    value: authored,
+    origins: [{ source: "literal", path: bindingPath, obtainedBy: "runtime" }]
+  };
+}
+function resolveFlowBindings(bindings, context, nodeOutputOrigin = {}, flowInputOrigins = {}) {
+  const values = {};
+  const origins = {};
+  const entries = Object.entries(bindings ?? {});
+  for (const [name] of entries) {
+    if (!FLOW_BINDING_NAME_PATTERN.test(name)) {
+      throw expressionError(`contains reserved binding name input.${name}`);
+    }
+  }
+  for (const [name, authored] of entries) {
+    const resolved = resolveBindingValue(
+      authored,
+      `input.${name}`,
+      context,
+      nodeOutputOrigin,
+      flowInputOrigins,
+      0
+    );
+    values[name] = resolved.value;
+    origins[name] = resolved.origins;
+  }
+  return { values, origins };
+}
 var nonEmptyString = z.string().min(1);
+var flowAssetIdentity = z.string().regex(
+  /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+  "Flow identity must be lowercase kebab-case without path separators"
+);
 var jsonSchema = z.record(z.string(), z.json());
+var bindingName = z.string().regex(FLOW_BINDING_NAME_PATTERN, "Binding name is reserved");
+var nodeBindings = z.preprocess(
+  (value, context) => {
+    if (typeof value === "object" && value !== null) {
+      for (const key of Object.keys(value)) {
+        if (!FLOW_BINDING_NAME_PATTERN.test(key)) {
+          context.addIssue({ code: "custom", path: [key], message: "Binding name is reserved" });
+        }
+      }
+    }
+    return value;
+  },
+  z.record(bindingName, z.json())
+);
 var FlowInputContractSchema = z.strictObject({
   schema: jsonSchema,
   example: z.json().optional()
@@ -377,7 +581,7 @@ var NodeOutputContractSchema = z.strictObject({
 });
 var NodeContractSchema = z.strictObject({
   requires: z.array(PreconditionSchema).optional(),
-  input: z.record(z.string(), z.json()).optional(),
+  input: nodeBindings.optional(),
   output: NodeOutputContractSchema.optional()
 });
 var NodeGateSchema = z.strictObject({
@@ -387,7 +591,8 @@ var NodeControlSchema = z.strictObject({
   optional: z.boolean().optional(),
   retries: z.number().int().min(0).optional(),
   timeoutSec: z.number().positive().optional(),
-  parallelGroup: nonEmptyString.optional()
+  parallelGroup: nonEmptyString.optional(),
+  subagent: z.boolean().optional()
 });
 var runAssets = { assets: z.array(nonEmptyString).optional() };
 var AgentRunSchema = z.strictObject({
@@ -461,13 +666,20 @@ var RouterRunSchema = z.strictObject({
   routes: z.array(RouteSchema).min(1),
   ...runAssets
 });
+var SubFlowRunSchema = z.strictObject({
+  kind: z.literal("sub-flow"),
+  flow: flowAssetIdentity,
+  passContext: z.boolean().optional(),
+  ...runAssets
+});
 var RunSchema = z.discriminatedUnion("kind", [
   AgentRunSchema,
   SubpromptRunSchema,
   FunctionRunSchema,
   CheckRunSchema,
   GateRunSchema,
-  RouterRunSchema
+  RouterRunSchema,
+  SubFlowRunSchema
 ]);
 var NodeSchema = z.strictObject({
   id: nonEmptyString,
@@ -524,14 +736,6 @@ var FlowDefinitionObjectSchema = z.strictObject({
 function parseFlowDefinitionStructure(data) {
   return FlowDefinitionObjectSchema.safeParse(data);
 }
-function bindingExpressions(value) {
-  if (typeof value === "string") {
-    return Array.from(value.matchAll(/\$\{([^{}]+)\}/g), (match) => match[1]);
-  }
-  if (Array.isArray(value)) return value.flatMap(bindingExpressions);
-  if (typeof value !== "object" || value === null) return [];
-  return Object.values(value).flatMap(bindingExpressions);
-}
 var MISSING_FIELD = /* @__PURE__ */ Symbol("missing-field");
 function declaredFieldSchema(schema, path) {
   let current = schema;
@@ -565,11 +769,11 @@ var FlowDefinitionSchema = FlowDefinitionObjectSchema.superRefine((flow, context
       });
     }
     nodeIds.add(node.id);
-    if (node.control?.optional === true && node.gate?.approval === "mandatory") {
+    if (node.control?.optional === true && (node.gate?.approval === "mandatory" || node.run.kind === "gate")) {
       context.addIssue({
         code: "custom",
         path: ["nodes", index, "control", "optional"],
-        message: "a node cannot be both optional and a mandatory approval gate"
+        message: node.run.kind === "gate" ? "a first-class gate node cannot be optional" : "a node cannot be both optional and a mandatory approval gate"
       });
     }
   }
@@ -680,11 +884,11 @@ var FlowDefinitionSchema = FlowDefinitionObjectSchema.superRefine((flow, context
         "expr"
       ]);
     }
-    for (const [bindingName, binding] of Object.entries(node.contract?.input ?? {})) {
-      for (const expression of bindingExpressions(binding)) {
+    for (const [bindingName2, binding] of Object.entries(node.contract?.input ?? {})) {
+      for (const expression of collectFlowBindingExpressions(binding)) {
         validateExpression(
           expression,
-          ["nodes", nodeIndex, "contract", "input", bindingName],
+          ["nodes", nodeIndex, "contract", "input", bindingName2],
           false
         );
       }
@@ -781,6 +985,8 @@ var LegacyNodeDataSchema = z.looseObject({
   phase: z.string().min(1).optional(),
   parallel_group: z.string().min(1).optional(),
   flow: z.string().min(1).optional(),
+  pass_context: z.boolean().optional(),
+  subagent: z.boolean().optional(),
   message: z.string().min(1).optional(),
   routes: z.array(LegacyRouteSchema).optional(),
   assets: z.array(z.string().min(1)).optional()
@@ -906,9 +1112,36 @@ function normalizeV1(data) {
     const kind = node.type;
     const label = data2.label ?? node.label ?? data2.skill ?? node.skill ?? node.id;
     const description = node.description ?? data2.description ?? data2.message ?? label;
+    if (kind === "sub-flow" && data2.flow) {
+      const delegatedAsset = `flow:${data2.flow}`;
+      const assets2 = [.../* @__PURE__ */ new Set([delegatedAsset, ...data2.assets ?? []])];
+      const parameters2 = data2.parameters ?? {};
+      const control2 = {
+        optional: data2.optional,
+        parallelGroup: data2.parallel_group,
+        subagent: data2.subagent
+      };
+      nodes.push({
+        id: node.id,
+        label,
+        description,
+        phase: data2.phase,
+        run: {
+          kind: "sub-flow",
+          flow: data2.flow,
+          passContext: data2.pass_context,
+          assets: assets2
+        },
+        contract: Object.keys(parameters2).length > 0 ? { input: normalizeLegacyBinding(parameters2) } : void 0,
+        control: Object.values(control2).some((value) => value !== void 0) ? control2 : void 0
+      });
+      continue;
+    }
     if (kind !== "skill") {
       const delegatedAsset = kind === "sub-flow" && data2.flow ? `flow:${data2.flow}` : void 0;
-      const assets2 = [...delegatedAsset ? [delegatedAsset] : [], ...data2.assets ?? []];
+      const assets2 = [
+        .../* @__PURE__ */ new Set([...delegatedAsset ? [delegatedAsset] : [], ...data2.assets ?? []])
+      ];
       const parameters2 = data2.parameters ?? {};
       nodes.push({
         id: node.id,
@@ -924,7 +1157,7 @@ function normalizeV1(data) {
           requires: [{ expr: "false" }],
           input: Object.keys(parameters2).length > 0 ? normalizeLegacyBinding(parameters2) : void 0
         },
-        control: { optional: true, parallelGroup: data2.parallel_group }
+        control: { optional: true, parallelGroup: data2.parallel_group, subagent: data2.subagent }
       });
       continue;
     }
@@ -937,7 +1170,8 @@ function normalizeV1(data) {
     const assets = [...skillAsset ? [skillAsset] : [], ...data2.assets ?? []];
     const control = {
       optional: data2.optional,
-      parallelGroup: data2.parallel_group
+      parallelGroup: data2.parallel_group,
+      subagent: data2.subagent
     };
     nodes.push({
       id: node.id,
@@ -951,7 +1185,7 @@ function normalizeV1(data) {
       },
       contract: Object.keys(parameters).length > 0 ? { input: normalizeLegacyBinding(parameters) } : void 0,
       gate: data2.approval?.mandatory === true ? { approval: "mandatory" } : void 0,
-      control: control.optional !== void 0 || control.parallelGroup !== void 0 ? control : void 0
+      control: Object.values(control).some((value) => value !== void 0) ? control : void 0
     });
   }
   const nodeIds = new Set(nodes.map((node) => node.id));
@@ -997,6 +1231,6 @@ function parseFlowDefinition(data) {
   return normalizeV1(data);
 }
 
-export { FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, evaluate, evaluateFlowExpression, normalizeV1, parseFlowDefinition };
-//# sourceMappingURL=chunk-ZE2KEPE2.js.map
-//# sourceMappingURL=chunk-ZE2KEPE2.js.map
+export { FLOW_EXPRESSION_LIMITS, FlowDefinitionSchema, FlowExpressionError, collectFlowBindingExpressions, evaluate, evaluateFlowExpression, inspectFlowExpression, normalizeV1, parseFlowDefinition, resolveFlowBindings, stableFlowJson };
+//# sourceMappingURL=chunk-OEGHKO5N.js.map
+//# sourceMappingURL=chunk-OEGHKO5N.js.map