@k2b/cloud 0.42.0 → 0.44.0

package/src/workflows/ai-actions.ts

@@ -1,4 +1,7 @@
+import { assertAiTaskRequestSize } from "../ai/task-contracts";
 import type { AiResolvedModel } from "../ai/types";
+import { type AiModelRequest, AiModelRequestSchema, type AiResolvedModelRef } from "../shared/ai-models";
+import { WorkflowAiAdmissionError, type WorkflowAiScope, workflowAiModelHash } from "./ai/policy";
 import type { WorkflowAiRequestInput, WorkflowAiTask } from "./ai/types";
 import type { WorkflowFieldSchema, WorkflowJsonValue } from "./contracts";
 import type { WorkflowActionContext, WorkflowActionResult, WorkflowPlannedEffect } from "./definition";
@@ -7,7 +10,14 @@ import { workflowAction } from "./definition";
 const text = (description: string, optional = false, maxLength = 20_000) =>
   ({ kind: "string", minLength: 1, maxLength, optional, description }) as const;
 const identifier = (description: string) => ({ kind: "string", format: "identifier", minLength: 1, maxLength: 120, description }) as const;
-const model = text("Optional enabled AI model profile ID.", true, 120);
+const model = {
+  kind: "union",
+  optional: true,
+  variants: [
+    { kind: "object", properties: { class: { kind: "string", enum: ["fast", "balanced", "thorough", "maximum"] } } },
+    { kind: "object", properties: { id: text("Explicit model variant ID.", false, 241) } },
+  ],
+} as const satisfies WorkflowFieldSchema;
 const prompt = text("Instructions for the AI task.");
 const choices = {
   kind: "array",
@@ -58,10 +68,13 @@ type WorkflowAiActionDependencies = {
     stepKey: string;
     effectKey: string;
     request: WorkflowAiRequestInput;
-    modelProfileId: string;
+    modelId: string;
+    modelRef?: AiResolvedModelRef;
+    modelConfigHash?: string;
+    scope?: WorkflowAiScope;
   }): Promise<{ task: WorkflowAiTask; created: boolean }>;
   exists(effectKey: string): Promise<boolean>;
-  resolveModel(requestedModelId?: string): Promise<AiResolvedModel>;
+  resolveModel(model?: AiModelRequest): Promise<AiResolvedModel>;
   submit(taskId: string): Promise<void>;
 };
 
@@ -83,7 +96,11 @@ const dependencies = async (): Promise<WorkflowAiActionDependencies> => {
 const failureCode = (error: unknown): string => {
   const code =
     (error as { aiError?: { code?: unknown }; code?: unknown } | null)?.aiError?.code ?? (error as { code?: unknown } | null)?.code;
-  return typeof code === "string" ? `WORKFLOW_AI_${code.toUpperCase()}` : "WORKFLOW_AI_UNAVAILABLE";
+  return typeof code === "string"
+    ? code.startsWith("WORKFLOW_AI_")
+      ? code
+      : `WORKFLOW_AI_${code.toUpperCase()}`
+    : "WORKFLOW_AI_UNAVAILABLE";
 };
 
 const taskResult = (task: WorkflowAiTask): WorkflowActionResult<WorkflowJsonValue> | null => {
@@ -105,6 +122,7 @@ export const runWorkflowAiAction = async (
   ctx: Pick<WorkflowActionContext, "runId" | "stepKey" | "effectKey">,
   request: WorkflowAiRequestInput,
   injected?: WorkflowAiActionDependencies,
+  scope?: () => Promise<WorkflowAiScope>,
 ): Promise<WorkflowActionResult<WorkflowJsonValue>> => {
   const deps = injected ?? (await dependencies());
   try {
@@ -113,14 +131,17 @@ export const runWorkflowAiAction = async (
     if (terminal) return terminal;
 
     if (!task) {
-      const resolved = await deps.resolveModel(request.modelProfileId?.trim() || undefined);
+      assertAiTaskRequestSize(request);
+      const resolved = await deps.resolveModel(request.model);
       task = (
         await deps.create({
           runId: ctx.runId,
           stepKey: ctx.stepKey,
           effectKey: ctx.effectKey,
           request,
-          modelProfileId: resolved.profile.id,
+          modelId: resolved.profile.id,
+          modelRef: resolved.model,
+          ...(scope ? { scope: await scope(), modelConfigHash: workflowAiModelHash(resolved.profile) } : {}),
         })
       ).task;
       const racedTerminal = taskResult(task);
@@ -134,7 +155,7 @@ export const runWorkflowAiAction = async (
       state: "failed",
       code: failureCode(error),
       message: error instanceof Error ? error.message : "Workflow AI task is unavailable.",
-      retryable: failureCode(error) === "WORKFLOW_AI_UNAVAILABLE",
+      retryable: error instanceof WorkflowAiAdmissionError ? error.retryable : failureCode(error) === "WORKFLOW_AI_UNAVAILABLE",
     };
   }
 };
@@ -149,124 +170,131 @@ export const workflowAiActionCost = async (
 
 const planWorkflowAiAction = async (summary: string): Promise<WorkflowPlannedEffect> => ({
   summary,
+  outputUnavailable: true,
   issues: ["AI output is not available during a dry run."],
 });
 
-export const AI_WORKFLOW_ACTIONS = {
-  aiExtractData: workflowAction.idempotent<typeof extractDataConfig, WorkflowJsonValue>({
-    label: "AI extract structured data",
-    description: "Extracts one bounded, validated object from supplied input.",
-    outputType: "core.value",
-    config: extractDataConfig,
-    cost: (ctx) => workflowAiActionCost(ctx),
-    plan: () => planWorkflowAiAction("Extract structured data with AI."),
-    run: (ctx, values) =>
-      runWorkflowAiAction(ctx, {
-        kind: "extract_data",
-        input: values.input,
-        prompt: values.prompt,
-        fields: values.fields,
-        ...(values.model ? { modelProfileId: values.model } : {}),
-      }),
-  }),
-  aiGenerateText: workflowAction.idempotent({
-    label: "AI generate text",
-    description: "Generates one bounded text value without performing a domain action.",
-    outputType: "core.text",
-    config: {
-      kind: "object",
-      properties: {
-        prompt,
-        input: { kind: "value", optional: true, description: "Optional JSON input supplied separately from the prompt." },
-        model,
-        maxOutputChars: {
-          kind: "number",
-          integer: true,
-          minimum: 1,
-          maximum: 20_000,
-          optional: true,
-          description: "Maximum generated text length. Defaults to 4000 characters.",
+export const createWorkflowAiActions = (options?: { scope(ctx: WorkflowActionContext): Promise<WorkflowAiScope> }) => {
+  const run = (ctx: WorkflowActionContext, request: WorkflowAiRequestInput) =>
+    runWorkflowAiAction(ctx, request, undefined, options ? () => options.scope(ctx) : undefined);
+  return {
+    aiExtractData: workflowAction.idempotent<typeof extractDataConfig, WorkflowJsonValue>({
+      label: "AI extract structured data",
+      description: "Extracts one bounded, validated object from supplied input.",
+      outputType: "core.value",
+      config: extractDataConfig,
+      cost: (ctx) => (ctx.invocation.mode === "dryRun" ? { maxAiCalls: 1 } : workflowAiActionCost(ctx)),
+      plan: () => planWorkflowAiAction("Extract structured data with AI."),
+      run: (ctx, values) =>
+        run(ctx, {
+          kind: "extract_data",
+          input: values.input,
+          prompt: values.prompt,
+          fields: values.fields,
+          ...(values.model ? { model: AiModelRequestSchema.parse(values.model) } : {}),
+        }),
+    }),
+    aiGenerateText: workflowAction.idempotent({
+      label: "AI generate text",
+      description: "Generates one bounded text value without performing a domain action.",
+      outputType: "core.text",
+      config: {
+        kind: "object",
+        properties: {
+          prompt,
+          input: { kind: "value", optional: true, description: "Optional JSON input supplied separately from the prompt." },
+          model,
+          maxOutputChars: {
+            kind: "number",
+            integer: true,
+            minimum: 1,
+            maximum: 20_000,
+            optional: true,
+            description: "Maximum generated text length. Defaults to 4000 characters.",
+          },
+          saveAs: identifier("Variable name for the generated text."),
         },
-        saveAs: identifier("Variable name for the generated text."),
       },
-    },
-    cost: (ctx) => workflowAiActionCost(ctx),
-    plan: () => planWorkflowAiAction("Generate text with AI."),
-    run: (ctx, values) =>
-      runWorkflowAiAction(ctx, {
-        kind: "generate_text",
-        prompt: values.prompt,
-        ...(values.input === undefined ? {} : { input: values.input }),
-        ...(values.model ? { modelProfileId: values.model } : {}),
-        ...(values.maxOutputChars === undefined ? {} : { maxOutputChars: values.maxOutputChars }),
-      }),
-  }),
-  aiClassify: workflowAction.idempotent({
-    label: "AI classify",
-    description: "Returns exactly one value from the declared choices.",
-    outputType: "core.text",
-    config: {
-      kind: "object",
-      properties: {
-        input: { kind: "value", description: "Bounded JSON value to classify." },
-        prompt,
-        choices,
-        model,
-        saveAs: identifier("Variable name for the selected choice."),
-      },
-    },
-    cost: (ctx) => workflowAiActionCost(ctx),
-    plan: () => planWorkflowAiAction("Classify one value with AI."),
-    run: (ctx, values) =>
-      runWorkflowAiAction(ctx, {
-        kind: "classify",
-        input: values.input,
-        prompt: values.prompt,
-        choices: values.choices,
-        ...(values.model ? { modelProfileId: values.model } : {}),
-      }),
-  }),
-  aiClassifyMany: workflowAction.idempotent({
-    label: "AI classify many",
-    description: "Returns a unique subset of the declared choices in their declared order.",
-    outputType: "core.textArray",
-    config: {
-      kind: "object",
-      properties: {
-        input: { kind: "value", description: "Bounded JSON value to classify." },
-        prompt,
-        choices,
-        minChoices: {
-          kind: "number",
-          integer: true,
-          minimum: 0,
-          maximum: 50,
-          optional: true,
-          description: "Minimum number of choices. Defaults to zero.",
+      cost: (ctx) => (ctx.invocation.mode === "dryRun" ? { maxAiCalls: 1 } : workflowAiActionCost(ctx)),
+      plan: () => planWorkflowAiAction("Generate text with AI."),
+      run: (ctx, values) =>
+        run(ctx, {
+          kind: "generate_text",
+          prompt: values.prompt,
+          ...(values.input === undefined ? {} : { input: values.input }),
+          ...(values.model ? { model: AiModelRequestSchema.parse(values.model) } : {}),
+          ...(values.maxOutputChars === undefined ? {} : { maxOutputChars: values.maxOutputChars }),
+        }),
+    }),
+    aiClassify: workflowAction.idempotent({
+      label: "AI classify",
+      description: "Returns exactly one value from the declared choices.",
+      outputType: "core.text",
+      config: {
+        kind: "object",
+        properties: {
+          input: { kind: "value", description: "Bounded JSON value to classify." },
+          prompt,
+          choices,
+          model,
+          saveAs: identifier("Variable name for the selected choice."),
         },
-        maxChoices: {
-          kind: "number",
-          integer: true,
-          minimum: 0,
-          maximum: 50,
-          optional: true,
-          description: "Maximum number of choices. Defaults to all declared choices.",
+      },
+      cost: (ctx) => (ctx.invocation.mode === "dryRun" ? { maxAiCalls: 1 } : workflowAiActionCost(ctx)),
+      plan: () => planWorkflowAiAction("Classify one value with AI."),
+      run: (ctx, values) =>
+        run(ctx, {
+          kind: "classify",
+          input: values.input,
+          prompt: values.prompt,
+          choices: values.choices,
+          ...(values.model ? { model: AiModelRequestSchema.parse(values.model) } : {}),
+        }),
+    }),
+    aiClassifyMany: workflowAction.idempotent({
+      label: "AI classify many",
+      description: "Returns a unique subset of the declared choices in their declared order.",
+      outputType: "core.textArray",
+      config: {
+        kind: "object",
+        properties: {
+          input: { kind: "value", description: "Bounded JSON value to classify." },
+          prompt,
+          choices,
+          minChoices: {
+            kind: "number",
+            integer: true,
+            minimum: 0,
+            maximum: 50,
+            optional: true,
+            description: "Minimum number of choices. Defaults to zero.",
+          },
+          maxChoices: {
+            kind: "number",
+            integer: true,
+            minimum: 0,
+            maximum: 50,
+            optional: true,
+            description: "Maximum number of choices. Defaults to all declared choices.",
+          },
+          model,
+          saveAs: identifier("Variable name for the selected choices."),
         },
-        model,
-        saveAs: identifier("Variable name for the selected choices."),
       },
-    },
-    cost: (ctx) => workflowAiActionCost(ctx),
-    plan: () => planWorkflowAiAction("Classify multiple values with AI."),
-    run: (ctx, values) =>
-      runWorkflowAiAction(ctx, {
-        kind: "classify_many",
-        input: values.input,
-        prompt: values.prompt,
-        choices: values.choices,
-        ...(values.minChoices === undefined ? {} : { minChoices: values.minChoices }),
-        ...(values.maxChoices === undefined ? {} : { maxChoices: values.maxChoices }),
-        ...(values.model ? { modelProfileId: values.model } : {}),
-      }),
-  }),
-} as const;
+      cost: (ctx) => (ctx.invocation.mode === "dryRun" ? { maxAiCalls: 1 } : workflowAiActionCost(ctx)),
+      plan: () => planWorkflowAiAction("Classify multiple values with AI."),
+      run: (ctx, values) =>
+        run(ctx, {
+          kind: "classify_many",
+          input: values.input,
+          prompt: values.prompt,
+          choices: values.choices,
+          ...(values.minChoices === undefined ? {} : { minChoices: values.minChoices }),
+          ...(values.maxChoices === undefined ? {} : { maxChoices: values.maxChoices }),
+          ...(values.model ? { model: AiModelRequestSchema.parse(values.model) } : {}),
+        }),
+    }),
+  } as const;
+};
+
+export const AI_WORKFLOW_ACTIONS = createWorkflowAiActions();

package/src/workflows/authoring.ts

@@ -64,6 +64,37 @@ export const buildWorkflowManifestCompletions = (
 ): WorkflowCompletionItem[] => {
   const manifest = workflows.manifest;
   const context = workflowCompletionContext(source, caret);
+  const indentation = context.line.match(/^\s*/)?.[0].length ?? 0;
+  const preceding = source
+    .slice(0, context.caret - context.line.length)
+    .trimEnd()
+    .split("\n");
+  const parent = preceding.findLast((line) => line.trim() && (line.match(/^\s*/)?.[0].length ?? 0) < indentation);
+  const inlineCondition = /^\s*(?:-\s*)?(?:if|not):\s*[A-Za-z]*$/.test(context.line);
+  const parentCondition = /^(\s*(?:-\s*)?)(?:if|all|any|not):\s*$/.exec(parent ?? "");
+  const blockCondition =
+    !context.key && /^\s*(?:-\s*)?[A-Za-z]*$/.test(context.line) && parentCondition && indentation > parentCondition[1]!.length;
+  if (inlineCondition || blockCondition) {
+    return [
+      "equals",
+      "notEquals",
+      "includes",
+      "textEquals",
+      "contains",
+      "startsWith",
+      "endsWith",
+      "greaterThan",
+      "lessThan",
+      "atLeast",
+      "atMost",
+      "exists",
+      "all",
+      "any",
+      "not",
+    ].map((operator) =>
+      workflowCompletionItem(context, "keyword", operator, inlineCondition ? `{ ${operator}: [] }` : `${operator}: `, "Workflow condition"),
+    );
+  }
   if (context.key === "type") {
     return manifest.inputs.map((input) => workflowCompletionItem(context, "literal", input.kind, input.kind, input.description));
   }

package/src/workflows/contracts.ts

@@ -107,6 +107,7 @@ export type WorkflowIrTrigger = {
 
 export type WorkflowCondition =
   | { operator: "equals" | "notEquals"; operands: [WorkflowJsonValue, WorkflowJsonValue] }
+  | { operator: "greaterThan" | "lessThan" | "atLeast" | "atMost"; operands: [WorkflowJsonValue, WorkflowJsonValue] }
   | { operator: "includes"; operands: [WorkflowJsonValue, WorkflowJsonValue] }
   | { operator: "textEquals" | "contains" | "startsWith" | "endsWith"; operands: [WorkflowJsonValue, WorkflowJsonValue] }
   | { operator: "exists"; reference: string }

package/src/workflows/definition.ts

@@ -144,6 +144,8 @@ export type WorkflowPlannedEffect = {
    * that cannot tell a planned record from a real one will act on a fiction.
    */
   output?: WorkflowJsonValue;
+  /** Omit the planned output when it cannot be predicted; explain why in `issues`. */
+  outputUnavailable?: true;
   /** Why the plan is not fully determined — surfaced in the dry-run view. */
   issues?: string[];
 };

package/src/workflows/editor.ts

@@ -77,6 +77,21 @@ export const createWorkflowYamlHighlighter = (workflows?: DefinedWorkflowModule)
     "required",
     "with",
     "if",
+    "equals",
+    "notEquals",
+    "includes",
+    "textEquals",
+    "contains",
+    "startsWith",
+    "endsWith",
+    "greaterThan",
+    "lessThan",
+    "atLeast",
+    "atMost",
+    "exists",
+    "all",
+    "any",
+    "not",
     "then",
     "else",
     "switch",

package/src/workflows/index.ts

@@ -1,4 +1,5 @@
-export { AI_WORKFLOW_ACTIONS } from "./ai-actions";
+export type { WorkflowAiBudget, WorkflowAiScope } from "./ai/policy";
+export { AI_WORKFLOW_ACTIONS, createWorkflowAiActions } from "./ai-actions";
 export {
   buildWorkflowManifestCompletions,
   type WorkflowCompletionContext,

package/src/workflows/language/compiler.ts

@@ -14,6 +14,7 @@ import type {
 } from "../contracts";
 import type { DefinedWorkflowModule } from "../module";
 import { hashWorkflowJson, hashWorkflowSource, normalizeWorkflowJson } from "./canonical";
+import { parseWorkflowValueString } from "./expressions";
 import { validateWorkflowField, workflowDiagnostic, workflowRecord } from "./schema";
 import { parseWorkflowYaml } from "./strict-yaml";
 
@@ -212,9 +213,23 @@ const compileCondition = (
   const operators = Object.keys(value);
   if (
     operators.length !== 1 ||
-    !["equals", "notEquals", "includes", "textEquals", "contains", "startsWith", "endsWith", "exists", "all", "any", "not"].includes(
-      operators[0]!,
-    )
+    ![
+      "equals",
+      "notEquals",
+      "includes",
+      "textEquals",
+      "contains",
+      "startsWith",
+      "endsWith",
+      "greaterThan",
+      "lessThan",
+      "atLeast",
+      "atMost",
+      "exists",
+      "all",
+      "any",
+      "not",
+    ].includes(operators[0]!)
   ) {
     addDiagnostic(context, "condition.operator", "Condition must contain exactly one supported operator", path);
     return undefined;
@@ -247,6 +262,22 @@ const compileCondition = (
     addDiagnostic(context, "condition.operands", `${operator} requires exactly two operands`, [...path, operator]);
     return undefined;
   }
+  if (operator === "greaterThan" || operator === "lessThan" || operator === "atLeast" || operator === "atMost") {
+    operand.forEach((value, index) => {
+      const expression = typeof value === "string" ? parseWorkflowValueString(value) : undefined;
+      if (
+        (typeof value !== "number" || !Number.isFinite(value)) &&
+        (expression?.kind !== "expression" || expression.expression.kind !== "reference")
+      ) {
+        addDiagnostic(context, "condition.type", `${operator} operand ${index + 1} must be a finite number or reference`, [
+          ...path,
+          operator,
+          index,
+        ]);
+      }
+    });
+    return { operator, operands: [normalizeWorkflowJson(operand[0]!), normalizeWorkflowJson(operand[1]!)] };
+  }
   return {
     operator: operator as "equals" | "notEquals" | "includes" | "textEquals" | "contains" | "startsWith" | "endsWith",
     operands: [normalizeWorkflowJson(operand[0]!), normalizeWorkflowJson(operand[1]!)],