@oomol-lab/open-flow 0.1.0-beta.75 → 0.1.0-beta.77

package/dist/common/openapi.d.ts

@@ -1,4 +1,4 @@
-import type { JsonValue, ManagedTaskDefinition } from './flow-change.js';
+import type { JsonValue, ManagedTaskDefinitionOf, TaskExecutor } from './flow-model.js';
 type ObjectValue = {
     [key: string]: JsonValue;
 };
@@ -36,14 +36,14 @@ export declare function securityOptions(value: JsonValue, path: string, method:
 }[];
 export declare function snapshot(documentValue: JsonValue, path: string, method: string): JsonValue;
 export declare function authHandles(auth: readonly OpenApiAuth[]): string[];
-export declare function openApiTask(config: OpenApiExecutor, name?: string): ManagedTaskDefinition;
+export declare function openApiTask(config: OpenApiExecutor, name?: string): ManagedTaskDefinitionOf<OpenApiExecutor>;
 export interface OpenApiFieldIssue {
     readonly field: 'sourceUrl' | 'operation' | 'serverUrl';
     readonly message: string;
 }
 /** The canvas validator and property panel share the same configuration contract. */
-export declare function openApiFieldIssues(task: ManagedTaskDefinition): OpenApiFieldIssue[];
-export declare function openApiIssues(task: ManagedTaskDefinition): string[];
+export declare function openApiFieldIssues<Executor extends TaskExecutor>(task: ManagedTaskDefinitionOf<Executor>): OpenApiFieldIssue[];
+export declare function openApiIssues(task: ManagedTaskDefinitionOf<TaskExecutor>): string[];
 export declare function selectOperation(value: JsonValue, sourceUrl: string, path: string, method: string): OpenApiExecutor;
 export declare function buildRequest(config: OpenApiExecutor, input: Readonly<Record<string, JsonValue>>): {
     url: string;

package/dist/common/openapi.js

@@ -3946,6 +3946,9 @@ function schema(doc, schemaValue) {
 		...Object.keys(defs).length ? { $defs: defs } : {}
 	};
 }
+function isOpenApiExecutor(executor) {
+	return executor.kind == "openapi";
+}
 function parameters(config) {
 	const doc = parseOpenApi(config.document);
 	const { item, op } = operation(doc, config.path, config.method);
@@ -4067,7 +4070,7 @@ function inlineSchema(value, index) {
 }
 /** The canvas validator and property panel share the same configuration contract. */
 function openApiFieldIssues(task) {
-	if (task.executor.kind != "openapi") return [];
+	if (!isOpenApiExecutor(task.executor)) return [];
 	const config = task.executor;
 	let field = "sourceUrl";
 	try {

package/dist/common/poll-trigger.d.ts

@@ -1,7 +1,8 @@
 export { resolveTriggerConfig, triggerConfigValues } from './trigger-config.js';
 import type { ConnectorProxy } from './connector-proxy.js';
-import type { JsonValue, TriggerKeySnapshot, TriggerSchedule } from './flow-change.js';
+import type { JsonValue } from './flow-model.js';
 import type { TriggerConfigOption, TriggerConfigOptionsContext } from './trigger-config-options.js';
+import type { TriggerKeySnapshot, TriggerSchedule } from './trigger-model.js';
 export declare const maximumPollCheckpointBytes: number;
 export declare const maximumPollDedupeKeyBytes = 1024;
 export declare const maximumPollEventsPerPage = 100;

package/dist/common/run-events.js

@@ -54,6 +54,7 @@ var nodeKinds = /* @__PURE__ */ new Set([
 	"javascript",
 	"openapi",
 	"http-request",
+	"dedupe",
 	"llm",
 	"value",
 	"wait",

package/dist/common/runtime-contract.d.ts

@@ -1,5 +1,19 @@
-import type { CodeModule, ConnectorCapability, TaskCapability, JsonValue } from './flow-change.js';
+import type { CodeModule, ConnectorCapability, TaskCapability, JsonValue } from './flow-model.js';
 export { currentEngineContract, nodejsEngineContract, findEngineContract, type EngineContract } from './engine-contract.js';
+/** Serialized into the guest; keep validation and helpers self-contained. */
+export declare function createState(invoke: (kind: string, payload: JsonValue) => Promise<RuntimeCapabilityResponse>): {
+    state: Readonly<{
+        get(key: unknown): Promise<JsonValue>;
+        set(key: unknown, value: unknown): Promise<void>;
+        insert(key: unknown, value: unknown): Promise<boolean>;
+        delete(key: unknown): Promise<void>;
+        list(): Promise<string[]>;
+    }>;
+    dedupe: Readonly<{
+        insert(ids: unknown): Promise<boolean[]>;
+        has(ids: unknown): Promise<boolean[]>;
+    }>;
+};
 export type RuntimeModule = Pick<CodeModule, 'imports' | 'source'>;
 /** Snapshot a Task result before JSON transport can discard or coerce invalid values. */
 export declare function snapshotRuntimeResult(value: unknown): JsonValue | undefined;
@@ -97,6 +111,28 @@ export interface DecisionTaskInvocation {
     readonly version: 1;
 }
 export type InvokeDecisionTask = (invocation: DecisionTaskInvocation) => Promise<LlmTaskResult>;
+/**
+ * Serialized into the sandbox before the Capability helpers that use it; keep it self-contained. Encodes in guest
+ * JavaScript, because Node compatibility `atob`/`btoa` route through bounded Host primitives.
+ */
+export declare function createBase64(): Readonly<{
+    encode(bytes: Uint8Array): string;
+    decode(text: unknown): Uint8Array;
+}>;
+/**
+ * Serialized into the sandbox; keep it self-contained. Transfers bytes as base64 chunks through
+ * `artifact.write`, `artifact.put` and `artifact.read` so each Capability message stays bounded.
+ */
+export declare function createArtifacts(invoke: (kind: string, payload: JsonValue) => Promise<RuntimeCapabilityResponse>, { decode, encode }?: ReturnType<typeof createBase64>): Readonly<{
+    put(data: unknown, options: unknown): Promise<JsonValue>;
+    open(ref: unknown): Promise<Uint8Array>;
+}>;
+/**
+ * Serialized into the sandbox; keep it self-contained. `context.fetch` sends one `http.fetch` Capability call per request.
+ * The Host authorizes the URL against the node's `http` Capability, does not follow redirects and adds no credentials.
+ * Request and response bodies are limited to 1 MiB; the response is a read-only subset of the Fetch `Response`.
+ */
+export declare function createFetch(invoke: (kind: string, payload: JsonValue) => Promise<RuntimeCapabilityResponse>, { decode, encode }?: ReturnType<typeof createBase64>): (input: unknown, init?: unknown) => Promise<unknown>;
 /** Serialized into the sandbox alongside the strict JSON snapshot helper. */
 export declare function createWorkflows(invoke: (payload: JsonValue) => Promise<RuntimeCapabilityResponse>): Readonly<{
     call(name: string, input?: Readonly<Record<string, JsonValue>>): Promise<JsonValue>;