@sequenceholdings/managed-functions 0.4.2 → 0.4.4

package/dist/lattice-provenance-contract.d.ts

@@ -54,6 +54,8 @@ export declare const functionLatticeParallelSnapshotQuerySchema: z.ZodObject<{
 export type FunctionLatticeParallelSnapshotQuery = z.infer<typeof functionLatticeParallelSnapshotQuerySchema>;
 export declare const functionLatticeContextRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     operation: z.ZodLiteral<"getExecutionContext">;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"getRunCreatorAccess">;
 }, z.core.$strict>, z.ZodObject<{
     nodeId: z.ZodString;
     stepId: z.ZodOptional<z.ZodString>;
@@ -69,6 +71,92 @@ export declare const functionLatticeContextRequestSchema: z.ZodDiscriminatedUnio
     operation: z.ZodLiteral<"getParallelSnapshot">;
 }, z.core.$strict>], "operation">;
 export type FunctionLatticeContextRequest = z.infer<typeof functionLatticeContextRequestSchema>;
+export declare const functionLatticeRunCreatorAccessSchema: z.ZodObject<{
+    receiverFunctionOrgId: z.ZodString;
+    parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        runId: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        stepId: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        input: z.ZodUnknown;
+        branch: z.ZodNullable<z.ZodObject<{
+            id: z.ZodString;
+            index: z.ZodNumber;
+            item: z.ZodUnknown;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    run: z.ZodObject<{
+        id: z.ZodString;
+        processId: z.ZodString;
+        processVersion: z.ZodString;
+        bundleHash: z.ZodString;
+        entity: z.ZodNullable<z.ZodObject<{
+            type: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strip>>;
+        startProvenance: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            version: z.ZodLiteral<1>;
+            issuer: z.ZodString;
+            runId: z.ZodString;
+            processId: z.ZodString;
+            processVersion: z.ZodString;
+            bundleHash: z.ZodString;
+            actorSub: z.ZodString;
+            startedBy: z.ZodNullable<z.ZodString>;
+            mode: z.ZodEnum<{
+                system: "system";
+                manual: "manual";
+                trigger: "trigger";
+                schedule: "schedule";
+                subprocess: "subprocess";
+                intervention: "intervention";
+            }>;
+            basis: z.ZodEnum<{
+                fga_invoker: "fga_invoker";
+                trusted_trigger: "trusted_trigger";
+                schedule_author: "schedule_author";
+                schedule_no_author: "schedule_no_author";
+                trusted_service: "trusted_service";
+                subprocess_spawn_gate: "subprocess_spawn_gate";
+                subprocess_parent_starter: "subprocess_parent_starter";
+                subprocess_existing_child: "subprocess_existing_child";
+                intervention_actor: "intervention_actor";
+            }>;
+            authorizedAt: z.ZodISODateTime;
+            schedule: z.ZodNullable<z.ZodObject<{
+                scheduleId: z.ZodString;
+                scheduledAt: z.ZodISODateTime;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strip>;
+    step: z.ZodObject<{
+        id: z.ZodString;
+        nodeId: z.ZodString;
+        attempt: z.ZodNumber;
+        runAsServiceAccount: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    receiver: z.ZodObject<{
+        functionId: z.ZodString;
+        versionId: z.ZodString;
+        invocationId: z.ZodString;
+        invoker: z.ZodObject<{
+            sub: z.ZodString;
+            kind: z.ZodString;
+            authenticationMethod: z.ZodString;
+        }, z.core.$strip>;
+        attachedServiceAccountSub: z.ZodString;
+    }, z.core.$strip>;
+    creator: z.ZodNullable<z.ZodObject<{
+        sub: z.ZodString;
+        tenant: z.ZodNullable<z.ZodString>;
+        platformOperator: z.ZodBoolean;
+    }, z.core.$strict>>;
+    observedAt: z.ZodISODateTime;
+}, z.core.$strip>;
+export type FunctionLatticeRunCreatorAccess = z.infer<typeof functionLatticeRunCreatorAccessSchema>;
 export declare const functionLatticeExecutionContextSchema: z.ZodObject<{
     receiverFunctionOrgId: z.ZodString;
     parent: z.ZodOptional<z.ZodNullable<z.ZodObject<{

package/dist/lattice-provenance-contract.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionLatticeContextError = exports.functionLatticeParallelSnapshotSchema = exports.functionLatticeHumanCompletionsPageSchema = exports.functionLatticeHumanCompletionSchema = exports.functionLatticeExecutionContextSchema = exports.functionLatticeContextRequestSchema = exports.functionLatticeParallelSnapshotQuerySchema = exports.functionLatticeHumanCompletionsQuerySchema = exports.functionLatticeHumanCompletionQuerySchema = exports.functionLatticeStartProvenanceSchema = exports.FUNCTION_LATTICE_CONTEXT_PATH = exports.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER = void 0;
+exports.FunctionLatticeContextError = exports.functionLatticeParallelSnapshotSchema = exports.functionLatticeHumanCompletionsPageSchema = exports.functionLatticeHumanCompletionSchema = exports.functionLatticeExecutionContextSchema = exports.functionLatticeRunCreatorAccessSchema = exports.functionLatticeContextRequestSchema = exports.functionLatticeParallelSnapshotQuerySchema = exports.functionLatticeHumanCompletionsQuerySchema = exports.functionLatticeHumanCompletionQuerySchema = exports.functionLatticeStartProvenanceSchema = exports.FUNCTION_LATTICE_CONTEXT_PATH = exports.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER = void 0;
 const zod_1 = require("zod");
 exports.FUNCTION_LATTICE_EXECUTION_TOKEN_HEADER = 'x-sequence-lattice-execution-token';
 exports.FUNCTION_LATTICE_CONTEXT_PATH = '/api/managed-functions/lattice/context';
@@ -29,6 +29,7 @@ exports.functionLatticeHumanCompletionsQuerySchema = exports.functionLatticeHuma
 exports.functionLatticeParallelSnapshotQuerySchema = zod_1.z.strictObject({ nodeId: identifier, ancestorNodeId: identifier });
 exports.functionLatticeContextRequestSchema = zod_1.z.discriminatedUnion('operation', [
     zod_1.z.strictObject({ operation: zod_1.z.literal('getExecutionContext') }),
+    zod_1.z.strictObject({ operation: zod_1.z.literal('getRunCreatorAccess') }),
     exports.functionLatticeHumanCompletionQuerySchema.extend({
         operation: zod_1.z.literal('getHumanCompletion'),
     }),
@@ -62,6 +63,14 @@ const executionIdentity = zod_1.z.object({
         attachedServiceAccountSub: principal,
     }),
 });
+exports.functionLatticeRunCreatorAccessSchema = executionIdentity.extend({
+    creator: zod_1.z.strictObject({
+        sub: principal,
+        tenant: zod_1.z.string().min(1).max(64).nullable(),
+        platformOperator: zod_1.z.boolean(),
+    }).nullable(),
+    observedAt: zod_1.z.iso.datetime({ offset: true }),
+});
 exports.functionLatticeExecutionContextSchema = executionIdentity.extend({
     input: zod_1.z.unknown(),
     ctxSnapshot: zod_1.z.object({

package/dist/lattice-provenance.d.ts

@@ -1,4 +1,4 @@
-import { type FunctionLatticeExecutionContext, type FunctionLatticeHumanCompletion, type FunctionLatticeHumanCompletionQuery, type FunctionLatticeHumanCompletionsQuery, type FunctionLatticeHumanCompletionsPage, type FunctionLatticeParallelSnapshot, type FunctionLatticeParallelSnapshotQuery } from './lattice-provenance-contract';
+import { type FunctionLatticeRunCreatorAccess, type FunctionLatticeExecutionContext, type FunctionLatticeHumanCompletion, type FunctionLatticeHumanCompletionQuery, type FunctionLatticeHumanCompletionsQuery, type FunctionLatticeHumanCompletionsPage, type FunctionLatticeParallelSnapshot, type FunctionLatticeParallelSnapshotQuery } from './lattice-provenance-contract';
 export * from './lattice-provenance-contract';
 export interface FunctionLatticeClientOptions {
     request: {
@@ -9,6 +9,7 @@ export interface FunctionLatticeClientOptions {
 }
 export interface FunctionLatticeClient {
     getExecutionContext(): Promise<FunctionLatticeExecutionContext>;
+    getRunCreatorAccess(): Promise<FunctionLatticeRunCreatorAccess>;
     getHumanCompletion(query: FunctionLatticeHumanCompletionQuery): Promise<FunctionLatticeHumanCompletion>;
     getHumanCompletions(query: FunctionLatticeHumanCompletionsQuery): Promise<FunctionLatticeHumanCompletionsPage>;
     getParallelSnapshot(query: FunctionLatticeParallelSnapshotQuery): Promise<FunctionLatticeParallelSnapshot>;

package/dist/lattice-provenance.js

@@ -139,6 +139,9 @@ function createFunctionLatticeClient({ request, baseUrl, fetchImpl = globalThis.
         getExecutionContext() {
             return read({ body: { operation: 'getExecutionContext' }, schema: lattice_provenance_contract_1.functionLatticeExecutionContextSchema, executions: (value) => [value] });
         },
+        getRunCreatorAccess() {
+            return read({ body: { operation: 'getRunCreatorAccess' }, schema: lattice_provenance_contract_1.functionLatticeRunCreatorAccessSchema, executions: value => [value] });
+        },
         async getHumanCompletion(query) {
             const completion = await read({
                 body: { ...query, operation: 'getHumanCompletion' },

package/dist/monitoring-contract.d.ts

@@ -3,8 +3,8 @@ import { functionMonitoringAnnotationSchema } from './monitoring-annotations';
 export type { DeltaEventInput as MonitoringDeltaEvent } from './monitoring-events';
 export declare const FUNCTION_MONITORING_TOKEN_HEADER = "x-sequence-monitoring-service-token";
 export declare const FUNCTION_MONITORING_DELIVERIES_PATH = "/api/managed-functions/monitoring/deliveries";
-export declare const MONITORING_PRODUCER_CAPABILITY = "emit_monitoring";
-export declare const MONITORING_CATALOG_CAPABILITY = "read_monitoring_catalog";
+export declare const MONITORING_PRODUCER_CAPABILITY = "emit-monitoring";
+export declare const MONITORING_CATALOG_CAPABILITY = "read-monitoring-catalog";
 export declare const MAX_MONITORING_DELIVERY_BYTES: number;
 export declare const functionMonitoringScopesSchema: z.ZodObject<{
     producers: z.ZodArray<z.ZodString>;

package/dist/monitoring-contract.js

@@ -9,8 +9,8 @@ const monitoring_events_1 = require("./monitoring-events");
 const monitoring_annotations_1 = require("./monitoring-annotations");
 exports.FUNCTION_MONITORING_TOKEN_HEADER = 'x-sequence-monitoring-service-token';
 exports.FUNCTION_MONITORING_DELIVERIES_PATH = '/api/managed-functions/monitoring/deliveries';
-exports.MONITORING_PRODUCER_CAPABILITY = 'emit_monitoring';
-exports.MONITORING_CATALOG_CAPABILITY = 'read_monitoring_catalog';
+exports.MONITORING_PRODUCER_CAPABILITY = 'emit-monitoring';
+exports.MONITORING_CATALOG_CAPABILITY = 'read-monitoring-catalog';
 exports.MAX_MONITORING_DELIVERY_BYTES = 512 * 1024;
 const producer = zod_1.z.string().min(1).max(41).regex(/^[a-z][a-z0-9_]{0,40}$/);
 exports.functionMonitoringScopesSchema = zod_1.z.strictObject({

package/dist/orm.d.ts

@@ -29,13 +29,16 @@ type SqlQueryVariables = {
     sql: string;
     parameters?: Record<string, SqlQueryParameter>;
 };
+type SqlQueryCell = string | number | boolean | null | SqlQueryCell[] | {
+    [key: string]: SqlQueryCell;
+};
 interface SqlQueryResult {
     columns: Array<{
         name: string;
         type: string;
         nullable: boolean;
     }>;
-    rows: Array<Array<string | number | boolean | null>>;
+    rows: Array<Array<SqlQueryCell>>;
     truncated: boolean;
 }
 

package/dist/preflight-invocation.js

@@ -12,20 +12,45 @@ function checkInvocationIdentity({ manifest, capabilities, tooling, cliVersion,
     const deployed = capabilities?.features.invocation_identity;
     const feature = deployed ?? capabilities_1.MANAGED_FUNCTION_CAPABILITIES.features.invocation_identity;
     const details = {
-        limit: feature.limit, tooling, requiredCli: feature.min_cli,
-        requiredSdk: feature.min_sdk, cliVersion, sdkVersion,
+        limit: feature.limit,
+        tooling,
+        requiredCli: feature.min_cli,
+        requiredSdk: feature.min_sdk,
+        cliVersion,
+        sdkVersion,
     };
     const parsed = invocation_contract_1.functionInvocationIdentityCapabilitySchema.safeParse(invocation);
     if (!parsed.success) {
         issues.push((0, preflight_issue_1.createPreflightIssue)({
-            ...details, field: 'capabilities.invocation',
+            ...details,
+            field: 'capabilities.invocation',
             problem: (0, capabilities_1.formatValidationDetail)(parsed.error.issues),
         }));
         return;
     }
+    if (parsed.data.caller_capabilities) {
+        const observed = capabilities?.features.invocation_caller_capabilities;
+        const required = capabilities_1.MANAGED_FUNCTION_CAPABILITIES.features.invocation_caller_capabilities;
+        if ((checkDeployment && observed?.supported !== true) ||
+            (0, capabilities_1.versionIsOlder)(cliVersion, required.min_cli) ||
+            !sdkVersion ||
+            (0, sdk_range_1.sdkConstraintIsOlder)(sdkVersion, required.min_sdk)) {
+            issues.push((0, preflight_issue_1.createPreflightIssue)({
+                limit: required.limit,
+                tooling,
+                requiredCli: required.min_cli,
+                requiredSdk: required.min_sdk,
+                cliVersion,
+                sdkVersion,
+                field: required.field,
+                problem: 'Current caller capability reads require deployed support and compatible tooling',
+            }));
+        }
+    }
     if (checkDeployment && deployed?.supported !== true) {
         issues.push((0, preflight_issue_1.createPreflightIssue)({
-            ...details, field: feature.field,
+            ...details,
+            field: feature.field,
             problem: 'Invocation identity reads are not supported by this deployment',
         }));
         return;
@@ -33,7 +58,8 @@ function checkInvocationIdentity({ manifest, capabilities, tooling, cliVersion,
     if ((0, capabilities_1.versionIsOlder)(cliVersion, feature.min_cli) ||
         (sdkVersion && (0, sdk_range_1.sdkConstraintIsOlder)(sdkVersion, feature.min_sdk))) {
         issues.push((0, preflight_issue_1.createPreflightIssue)({
-            ...details, field: feature.field,
+            ...details,
+            field: feature.field,
             problem: 'the installed tooling does not support managed function invocation identity reads',
         }));
     }

package/dist/preflight-service-directory-roster.d.ts

@@ -0,0 +1,2 @@
+import type { checkDirectory } from './preflight-service-directory';
+export declare function checkDirectoryRosters({ capabilities, tooling, cliVersion, sdkVersion, checkDeployment, issues }: Parameters<typeof checkDirectory>[0]): void;

package/dist/preflight-service-directory-roster.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDirectoryRosters = checkDirectoryRosters;
+const capabilities_1 = require("./capabilities");
+const preflight_issue_1 = require("./preflight-issue");
+const sdk_range_1 = require("./sdk-range");
+function checkDirectoryRosters({ capabilities, tooling, cliVersion, sdkVersion, checkDeployment, issues }) {
+    const deployed = capabilities?.features.directory_rosters;
+    const feature = deployed ?? capabilities_1.MANAGED_FUNCTION_CAPABILITIES.features.directory_rosters;
+    const details = { field: feature.field, limit: feature.limit, tooling, requiredCli: feature.min_cli, requiredSdk: feature.min_sdk, cliVersion, sdkVersion };
+    if (checkDeployment && deployed?.supported !== true) {
+        issues.push((0, preflight_issue_1.createPreflightIssue)({ ...details, problem: 'scoped service group rosters are not supported by this deployment' }));
+        return;
+    }
+    if ((0, capabilities_1.versionIsOlder)(cliVersion, feature.min_cli) || (sdkVersion && (0, sdk_range_1.sdkConstraintIsOlder)(sdkVersion, feature.min_sdk)))
+        issues.push((0, preflight_issue_1.createPreflightIssue)({ ...details, problem: 'the installed tooling does not support scoped service group rosters' }));
+}

package/dist/preflight.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preflightManagedFunction = preflightManagedFunction;
+const preflight_service_directory_roster_1 = require("./preflight-service-directory-roster");
 const capabilities_1 = require("./capabilities");
 const sdk_range_1 = require("./sdk-range");
 const preflight_issue_1 = require("./preflight-issue");
@@ -206,6 +207,8 @@ function checkDirectoryDeclarations(args) {
         return;
     }
     const scoped = (directory) => ({ ...args, manifest: { ...args.manifest, capabilities: { ...args.manifest.capabilities, directory } } });
+    if (parsed.data.rosters)
+        (0, preflight_service_directory_roster_1.checkDirectoryRosters)(args);
     if (parsed.data.groups)
         (0, preflight_directory_1.checkDirectory)(scoped({ groups: parsed.data.groups }));
     if (parsed.data.resolve)

package/dist/processes-contract.d.ts

@@ -55,6 +55,21 @@ export declare const functionProcessRunsPageQuerySchema: z.ZodObject<{
     archived: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 export type FunctionProcessRunQuery = z.infer<typeof functionProcessRunQuerySchema>;
+export declare const functionProcessCompletedNodeQuerySchema: z.ZodObject<{
+    process: z.ZodString;
+    runId: z.ZodString;
+    nodeId: z.ZodString;
+}, z.core.$strict>;
+export type FunctionProcessCompletedNodeQuery = z.infer<typeof functionProcessCompletedNodeQuerySchema>;
+export declare const functionProcessCompletedNodeSchema: z.ZodObject<{
+    runId: z.ZodString;
+    processId: z.ZodString;
+    processVersion: z.ZodString;
+    nodeId: z.ZodString;
+    stepId: z.ZodString;
+    completedAt: z.ZodISODateTime;
+}, z.core.$strict>;
+export type FunctionProcessCompletedNode = z.infer<typeof functionProcessCompletedNodeSchema>;
 export declare const functionProcessCompletedAgentReferenceQuerySchema: z.ZodObject<{
     process: z.ZodString;
     runId: z.ZodString;
@@ -95,6 +110,11 @@ export declare const functionProcessReadRequestSchema: z.ZodDiscriminatedUnion<[
     process: z.ZodString;
     runId: z.ZodString;
     operation: z.ZodLiteral<"getRun">;
+}, z.core.$strict>, z.ZodObject<{
+    process: z.ZodString;
+    runId: z.ZodString;
+    nodeId: z.ZodString;
+    operation: z.ZodLiteral<"getCompletedNode">;
 }, z.core.$strict>, z.ZodObject<{
     process: z.ZodString;
     runId: z.ZodString;

package/dist/processes-contract.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FunctionProcessReadError = exports.functionProcessReadRequestSchema = exports.functionProcessRunsPageSchema = exports.functionProcessCompletedAgentReferenceSchema = exports.functionProcessCompletedAgentReferenceQuerySchema = exports.functionProcessRunsPageQuerySchema = exports.functionProcessRunQuerySchema = exports.functionProcessRunSummarySchema = exports.functionProcessRunStatusSchema = exports.functionProcessReadScopesSchema = exports.FUNCTION_PROCESS_READ_PATH = exports.FUNCTION_PROCESS_TOKEN_HEADER = void 0;
+exports.FunctionProcessReadError = exports.functionProcessReadRequestSchema = exports.functionProcessRunsPageSchema = exports.functionProcessCompletedAgentReferenceSchema = exports.functionProcessCompletedAgentReferenceQuerySchema = exports.functionProcessCompletedNodeSchema = exports.functionProcessCompletedNodeQuerySchema = exports.functionProcessRunsPageQuerySchema = exports.functionProcessRunQuerySchema = exports.functionProcessRunSummarySchema = exports.functionProcessRunStatusSchema = exports.functionProcessReadScopesSchema = exports.FUNCTION_PROCESS_READ_PATH = exports.FUNCTION_PROCESS_TOKEN_HEADER = void 0;
 exports.readFunctionProcessScopes = readFunctionProcessScopes;
 const zod_1 = require("zod");
 exports.FUNCTION_PROCESS_TOKEN_HEADER = 'x-sequence-process-service-token';
@@ -66,6 +66,11 @@ exports.functionProcessRunsPageQuerySchema = zod_1.z.strictObject({
     cursor: zod_1.z.string().min(1).max(8192).optional(),
     archived: zod_1.z.boolean().optional(),
 });
+exports.functionProcessCompletedNodeQuerySchema = exports.functionProcessRunQuerySchema.extend({ nodeId: entityId });
+exports.functionProcessCompletedNodeSchema = zod_1.z.strictObject({
+    runId: entityId, processId, processVersion: entityId, nodeId: entityId, stepId: entityId,
+    completedAt: zod_1.z.iso.datetime({ offset: true }),
+});
 exports.functionProcessCompletedAgentReferenceQuerySchema = exports.functionProcessRunQuerySchema.extend({ nodeId: entityId });
 exports.functionProcessCompletedAgentReferenceSchema = zod_1.z.strictObject({
     stepId: entityId, attempt: zod_1.z.number().int().positive().max(Number.MAX_SAFE_INTEGER),
@@ -78,6 +83,7 @@ exports.functionProcessRunsPageSchema = zod_1.z.object({
 });
 exports.functionProcessReadRequestSchema = zod_1.z.discriminatedUnion('operation', [
     exports.functionProcessRunQuerySchema.extend({ operation: zod_1.z.literal('getRun') }),
+    exports.functionProcessCompletedNodeQuerySchema.extend({ operation: zod_1.z.literal('getCompletedNode') }),
     exports.functionProcessCompletedAgentReferenceQuerySchema.extend({ operation: zod_1.z.literal('getCompletedAgentReference') }),
     exports.functionProcessRunsPageQuerySchema.extend({
         operation: zod_1.z.literal('listRunsPage'),

package/dist/processes.d.ts

@@ -1,8 +1,9 @@
-import { type FunctionProcessCompletedAgentReference, type FunctionProcessCompletedAgentReferenceQuery, type FunctionProcessRunQuery, type FunctionProcessRunSummary, type FunctionProcessRunsPage, type FunctionProcessRunsPageQuery } from './processes-contract';
+import { type FunctionProcessCompletedNode, type FunctionProcessCompletedNodeQuery, type FunctionProcessCompletedAgentReference, type FunctionProcessCompletedAgentReferenceQuery, type FunctionProcessRunQuery, type FunctionProcessRunSummary, type FunctionProcessRunsPage, type FunctionProcessRunsPageQuery } from './processes-contract';
 import { type FunctionInvocationClientOptions } from './invocation-client';
 export * from './processes-contract';
 export type FunctionServiceProcessesOptions = FunctionInvocationClientOptions;
 export interface FunctionServiceProcessesClient {
+    getCompletedNode(query: FunctionProcessCompletedNodeQuery): Promise<FunctionProcessCompletedNode>;
     getCompletedAgentReference(query: FunctionProcessCompletedAgentReferenceQuery): Promise<FunctionProcessCompletedAgentReference>;
     getRun(query: FunctionProcessRunQuery): Promise<FunctionProcessRunSummary>;
     listRunsPage(query: FunctionProcessRunsPageQuery): Promise<FunctionProcessRunsPage>;

package/dist/processes.js

@@ -70,6 +70,12 @@ function createFunctionServiceProcessesClient({ request, baseUrl, fetchImpl = gl
     });
     const read = ({ body, schema }) => transport({ body: processes_contract_1.functionProcessReadRequestSchema.parse(body), schema });
     return {
+        async getCompletedNode(query) {
+            const proof = await read({ body: { ...query, operation: 'getCompletedNode' }, schema: processes_contract_1.functionProcessCompletedNodeSchema });
+            if (proof.runId !== query.runId || proof.processId !== query.process || proof.nodeId !== query.nodeId)
+                throw new processes_contract_1.FunctionProcessReadError(502, 'malformed_response', 'Atlas returned a different completed node');
+            return proof;
+        },
         async getCompletedAgentReference(query) {
             const agent = readAgentCredential({ request });
             const readReference = (0, invocation_client_1.createInvocationReadTransport)({