@sequenceholdings/managed-functions 0.4.5 → 0.5.1

package/dist/platform-domains.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FUNCTION_PLATFORM_DOMAIN_HEADERS = void 0;
+exports.createFunctionPlatformDomains = createFunctionPlatformDomains;
+const directory_1 = require("./directory");
+const agents_1 = require("./agents");
+const agent_evidence_1 = require("./agent-evidence");
+const workflow_source_1 = require("./workflow-source");
+const monitoring_1 = require("./monitoring");
+const abrigo_1 = require("./abrigo");
+const storage_1 = require("./storage");
+exports.FUNCTION_PLATFORM_DOMAIN_HEADERS = [
+    "x-sequence-directory-token",
+    "x-sequence-storage-token",
+    "x-sequence-storage-token-service",
+    "x-sequence-agent-evidence-token",
+    "x-sequence-workflow-service-token",
+    "x-sequence-workflow-evidence-token",
+    "x-sequence-monitoring-service-token",
+    "x-sequence-abrigo-read-token",
+];
+function lazy(create) {
+    let value;
+    return () => (value ??= create());
+}
+function createFunctionPlatformDomains(context) {
+    const callerDirectory = lazy(() => (0, directory_1.createFunctionDirectoryClient)(context));
+    const agents = lazy(() => (0, agents_1.createFunctionServiceAgentsClient)(context));
+    const agentEvidence = lazy(() => (0, agent_evidence_1.createFunctionAgentEvidenceClient)(context));
+    const workflows = lazy(() => (0, workflow_source_1.createFunctionServiceWorkflowsClient)(context));
+    const workflowEvidence = lazy(() => (0, workflow_source_1.createFunctionWorkflowEvidenceClient)(context));
+    const monitoring = lazy(() => (0, monitoring_1.createFunctionServiceMonitoringClient)(context));
+    const abrigo = lazy(() => (0, abrigo_1.createFunctionCallerAbrigoClient)(context));
+    function storage(mode) {
+        const client = lazy(() => (0, storage_1.createFunctionStorageClient)({
+            baseUrl: context.baseUrl,
+            headers: context.request.headers,
+            mode,
+            fetchImpl: context.fetchImpl,
+        }));
+        return {
+            capabilities: async () => client().capabilities(),
+            list: async (options) => client().list(options),
+            shared: async (options) => client().shared(options),
+            apply: async (manifest) => client().apply(manifest),
+            workspace: (id) => client().workspace(id),
+        };
+    }
+    return {
+        callerDirectory: {
+            resolveMembers: async (query) => callerDirectory().resolveMembers(query),
+        },
+        agents: {
+            getCompletedRun: async (query) => agents().getCompletedRun(query),
+            captureCompletedRun: async (query) => agents().captureCompletedRun(query),
+            evidence: {
+                verifySourceEvidence: async (input) => agentEvidence().verifySourceEvidence(input),
+                verifyConversationEvidence: async (input) => agentEvidence().verifyConversationEvidence(input),
+            },
+        },
+        workflows: {
+            captureCompletedRun: async (query) => workflows().captureCompletedRun(query),
+            evidence: {
+                verifySourceEvidence: async (input) => workflowEvidence().verifySourceEvidence(input),
+            },
+        },
+        monitoring: {
+            publish: async (input) => monitoring().publish(input),
+            get: async (input) => monitoring().get(input),
+            getBucketCatalog: async (input) => monitoring().getBucketCatalog(input),
+        },
+        abrigo: {
+            read: async (input) => abrigo().read(input),
+        },
+        storage: { caller: storage("user"), service: storage("service") },
+    };
+}

package/dist/processes-contract.d.ts

@@ -1,149 +1,2 @@
-import { z } from 'zod';
-export declare const FUNCTION_PROCESS_TOKEN_HEADER = "x-sequence-process-service-token";
-export declare const FUNCTION_PROCESS_READ_PATH = "/api/managed-functions/processes/read";
-export declare const functionProcessReadScopesSchema: z.ZodObject<{
-    read: z.ZodArray<z.ZodString>;
-}, z.core.$strict>;
-export declare function readFunctionProcessScopes(manifest: unknown): string[];
-export declare const functionProcessRunStatusSchema: z.ZodEnum<{
-    pending: "pending";
-    running: "running";
-    completed: "completed";
-    failed: "failed";
-    cancelled: "cancelled";
-    timed_out: "timed_out";
-}>;
-export type FunctionProcessRunStatus = z.infer<typeof functionProcessRunStatusSchema>;
-export declare const functionProcessRunSummarySchema: z.ZodObject<{
-    id: z.ZodString;
-    processId: z.ZodString;
-    status: z.ZodEnum<{
-        pending: "pending";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        cancelled: "cancelled";
-        timed_out: "timed_out";
-    }>;
-    entityType: z.ZodNullable<z.ZodString>;
-    entityId: z.ZodNullable<z.ZodString>;
-    startedAt: z.ZodISODateTime;
-    completedAt: z.ZodNullable<z.ZodISODateTime>;
-}, z.core.$strip>;
-export type FunctionProcessRunSummary = z.infer<typeof functionProcessRunSummarySchema>;
-export declare const functionProcessRunQuerySchema: z.ZodObject<{
-    process: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strict>;
-export declare const functionProcessRunsPageQuerySchema: z.ZodObject<{
-    process: z.ZodString;
-    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        pending: "pending";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        cancelled: "cancelled";
-        timed_out: "timed_out";
-    }>>>;
-    entity: z.ZodOptional<z.ZodObject<{
-        type: z.ZodString;
-        id: z.ZodOptional<z.ZodString>;
-        ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-    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;
-    nodeId: z.ZodString;
-}, z.core.$strict>;
-export type FunctionProcessCompletedAgentReferenceQuery = z.infer<typeof functionProcessCompletedAgentReferenceQuerySchema>;
-export declare const functionProcessCompletedAgentReferenceSchema: z.ZodObject<{
-    stepId: z.ZodString;
-    attempt: z.ZodNumber;
-    agentId: z.ZodString;
-    agentRunId: z.ZodString;
-    threadId: z.ZodString;
-    recoveryProof: z.ZodString;
-}, z.core.$strict>;
-export type FunctionProcessCompletedAgentReference = z.infer<typeof functionProcessCompletedAgentReferenceSchema>;
-export type FunctionProcessRunsPageQuery = z.infer<typeof functionProcessRunsPageQuerySchema>;
-export declare const functionProcessRunsPageSchema: z.ZodObject<{
-    runs: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        processId: z.ZodString;
-        status: z.ZodEnum<{
-            pending: "pending";
-            running: "running";
-            completed: "completed";
-            failed: "failed";
-            cancelled: "cancelled";
-            timed_out: "timed_out";
-        }>;
-        entityType: z.ZodNullable<z.ZodString>;
-        entityId: z.ZodNullable<z.ZodString>;
-        startedAt: z.ZodISODateTime;
-        completedAt: z.ZodNullable<z.ZodISODateTime>;
-    }, z.core.$strip>>;
-    nextCursor: z.ZodNullable<z.ZodString>;
-}, z.core.$strip>;
-export type FunctionProcessRunsPage = z.infer<typeof functionProcessRunsPageSchema>;
-export declare const functionProcessReadRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    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;
-    nodeId: z.ZodString;
-    operation: z.ZodLiteral<"getCompletedAgentReference">;
-}, z.core.$strict>, z.ZodObject<{
-    process: z.ZodString;
-    statuses: z.ZodOptional<z.ZodArray<z.ZodEnum<{
-        pending: "pending";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        cancelled: "cancelled";
-        timed_out: "timed_out";
-    }>>>;
-    entity: z.ZodOptional<z.ZodObject<{
-        type: z.ZodString;
-        id: z.ZodOptional<z.ZodString>;
-        ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strict>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    cursor: z.ZodOptional<z.ZodString>;
-    archived: z.ZodOptional<z.ZodBoolean>;
-    operation: z.ZodLiteral<"listRunsPage">;
-}, z.core.$strict>], "operation">;
-export type FunctionProcessReadRequest = z.infer<typeof functionProcessReadRequestSchema>;
-export declare class FunctionProcessReadError extends Error {
-    readonly status: number;
-    readonly code: string;
-    readonly name = "FunctionProcessReadError";
-    constructor(status: number, code: string, message: string);
-}
+export { FUNCTION_PROCESS_TOKEN_HEADER, FUNCTION_PROCESS_READ_PATH, functionProcessReadScopesSchema, readFunctionProcessScopes, functionProcessRunStatusSchema, functionProcessRunSummarySchema, functionProcessRunQuerySchema, functionProcessRunsPageQuerySchema, functionProcessCompletedNodeQuerySchema, functionProcessCompletedNodeSchema, functionProcessCompletedAgentReferenceQuerySchema, functionProcessCompletedAgentReferenceSchema, functionProcessRunsPageSchema, functionProcessReadRequestSchema, FunctionProcessReadError, } from "@sequenceholdings/platform/contracts";
+export type { FunctionProcessRunStatus, FunctionProcessRunSummary, FunctionProcessRunQuery, FunctionProcessCompletedNodeQuery, FunctionProcessCompletedNode, FunctionProcessCompletedAgentReferenceQuery, FunctionProcessCompletedAgentReference, FunctionProcessRunsPageQuery, FunctionProcessRunsPage, FunctionProcessReadRequest, } from "@sequenceholdings/platform/contracts";

package/dist/processes-contract.js

@@ -1,102 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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';
-exports.FUNCTION_PROCESS_READ_PATH = '/api/managed-functions/processes/read';
-const processId = zod_1.z
-    .string()
-    .min(1)
-    .max(255)
-    .regex(/^[A-Za-z0-9._-]+$/);
-const entityId = zod_1.z.string().min(1).max(255);
-exports.functionProcessReadScopesSchema = zod_1.z.strictObject({
-    read: zod_1.z
-        .array(processId)
-        .min(1)
-        .max(64)
-        .refine((ids) => new Set(ids).size === ids.length, 'Process ids must be distinct')
-        .refine((ids) => ids.reduce((bytes, id) => bytes + id.length, 0) <= 8192, 'Process ids must fit within 8192 bytes'),
-});
-function readFunctionProcessScopes(manifest) {
-    if (typeof manifest !== 'object' || manifest === null)
-        return [];
-    const capabilities = Reflect.get(manifest, 'capabilities');
-    if (typeof capabilities !== 'object' || capabilities === null)
-        return [];
-    const processes = Reflect.get(capabilities, 'processes');
-    if (processes === undefined)
-        return [];
-    return exports.functionProcessReadScopesSchema.parse(processes).read;
-}
-exports.functionProcessRunStatusSchema = zod_1.z.enum([
-    'pending',
-    'running',
-    'completed',
-    'failed',
-    'cancelled',
-    'timed_out',
-]);
-exports.functionProcessRunSummarySchema = zod_1.z.object({
-    id: zod_1.z.string().min(1).max(255),
-    processId,
-    status: exports.functionProcessRunStatusSchema,
-    entityType: zod_1.z.string().max(255).nullable(),
-    entityId: zod_1.z.string().max(255).nullable(),
-    startedAt: zod_1.z.iso.datetime({ offset: true }),
-    completedAt: zod_1.z.iso.datetime({ offset: true }).nullable(),
-});
-exports.functionProcessRunQuerySchema = zod_1.z.strictObject({
-    process: processId,
-    runId: zod_1.z.string().min(1).max(255),
-});
-exports.functionProcessRunsPageQuerySchema = zod_1.z.strictObject({
-    process: processId,
-    statuses: zod_1.z.array(exports.functionProcessRunStatusSchema).min(1).max(6).optional(),
-    entity: zod_1.z
-        .strictObject({
-        type: entityId,
-        id: entityId.optional(),
-        ids: zod_1.z.array(entityId).min(1).max(500).optional(),
-    })
-        .refine((value) => value.id === undefined || value.ids === undefined, 'Name one entity id or a set, not both')
-        .optional(),
-    limit: zod_1.z.number().int().min(1).max(500).optional(),
-    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),
-    agentId: entityId, agentRunId: entityId, threadId: entityId,
-    recoveryProof: zod_1.z.string().min(1).max(16_384),
-});
-exports.functionProcessRunsPageSchema = zod_1.z.object({
-    runs: zod_1.z.array(exports.functionProcessRunSummarySchema).max(500),
-    nextCursor: zod_1.z.string().nullable(),
-});
-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'),
-    }),
-]);
-class FunctionProcessReadError extends Error {
-    status;
-    code;
-    name = 'FunctionProcessReadError';
-    constructor(status, code, message) {
-        super(message);
-        this.status = status;
-        this.code = code;
-    }
-}
-exports.FunctionProcessReadError = FunctionProcessReadError;
+exports.FunctionProcessReadError = exports.functionProcessReadRequestSchema = exports.functionProcessRunsPageSchema = exports.functionProcessCompletedAgentReferenceSchema = exports.functionProcessCompletedAgentReferenceQuerySchema = exports.functionProcessCompletedNodeSchema = exports.functionProcessCompletedNodeQuerySchema = exports.functionProcessRunsPageQuerySchema = exports.functionProcessRunQuerySchema = exports.functionProcessRunSummarySchema = exports.functionProcessRunStatusSchema = exports.readFunctionProcessScopes = exports.functionProcessReadScopesSchema = exports.FUNCTION_PROCESS_READ_PATH = exports.FUNCTION_PROCESS_TOKEN_HEADER = void 0;
+var contracts_1 = require("@sequenceholdings/platform/contracts");
+Object.defineProperty(exports, "FUNCTION_PROCESS_TOKEN_HEADER", { enumerable: true, get: function () { return contracts_1.FUNCTION_PROCESS_TOKEN_HEADER; } });
+Object.defineProperty(exports, "FUNCTION_PROCESS_READ_PATH", { enumerable: true, get: function () { return contracts_1.FUNCTION_PROCESS_READ_PATH; } });
+Object.defineProperty(exports, "functionProcessReadScopesSchema", { enumerable: true, get: function () { return contracts_1.functionProcessReadScopesSchema; } });
+Object.defineProperty(exports, "readFunctionProcessScopes", { enumerable: true, get: function () { return contracts_1.readFunctionProcessScopes; } });
+Object.defineProperty(exports, "functionProcessRunStatusSchema", { enumerable: true, get: function () { return contracts_1.functionProcessRunStatusSchema; } });
+Object.defineProperty(exports, "functionProcessRunSummarySchema", { enumerable: true, get: function () { return contracts_1.functionProcessRunSummarySchema; } });
+Object.defineProperty(exports, "functionProcessRunQuerySchema", { enumerable: true, get: function () { return contracts_1.functionProcessRunQuerySchema; } });
+Object.defineProperty(exports, "functionProcessRunsPageQuerySchema", { enumerable: true, get: function () { return contracts_1.functionProcessRunsPageQuerySchema; } });
+Object.defineProperty(exports, "functionProcessCompletedNodeQuerySchema", { enumerable: true, get: function () { return contracts_1.functionProcessCompletedNodeQuerySchema; } });
+Object.defineProperty(exports, "functionProcessCompletedNodeSchema", { enumerable: true, get: function () { return contracts_1.functionProcessCompletedNodeSchema; } });
+Object.defineProperty(exports, "functionProcessCompletedAgentReferenceQuerySchema", { enumerable: true, get: function () { return contracts_1.functionProcessCompletedAgentReferenceQuerySchema; } });
+Object.defineProperty(exports, "functionProcessCompletedAgentReferenceSchema", { enumerable: true, get: function () { return contracts_1.functionProcessCompletedAgentReferenceSchema; } });
+Object.defineProperty(exports, "functionProcessRunsPageSchema", { enumerable: true, get: function () { return contracts_1.functionProcessRunsPageSchema; } });
+Object.defineProperty(exports, "functionProcessReadRequestSchema", { enumerable: true, get: function () { return contracts_1.functionProcessReadRequestSchema; } });
+Object.defineProperty(exports, "FunctionProcessReadError", { enumerable: true, get: function () { return contracts_1.FunctionProcessReadError; } });

package/dist/processes.d.ts

@@ -1,6 +1,6 @@
-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';
+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>;

package/dist/processes.js

@@ -15,35 +15,49 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createFunctionServiceProcessesClient = createFunctionServiceProcessesClient;
+const browser_1 = require("@sequenceholdings/platform/browser");
 const zod_1 = require("zod");
 const processes_contract_1 = require("./processes-contract");
 const invocation_client_1 = require("./invocation-client");
 const agents_contract_1 = require("./agents-contract");
 __exportStar(require("./processes-contract"), exports);
-function readAgentCredential({ request }) {
+function readAgentCredential({ request, }) {
     const { headers } = request;
-    const matches = typeof headers.get === 'function' ? [headers.get(agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER)]
-        : Object.entries(headers).filter(([name]) => name.toLowerCase() === agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER).map(([, value]) => value);
+    const matches = typeof headers.get === "function"
+        ? [headers.get(agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER)]
+        : Object.entries(headers)
+            .filter(([name]) => name.toLowerCase() === agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER)
+            .map(([, value]) => value);
     const token = matches[0];
-    const denied = () => new processes_contract_1.FunctionProcessReadError(401, 'invalid_context', 'Completed-agent reference lookup requires an agent-read credential');
-    if (matches.length !== 1 || typeof token !== 'string' || token.length > 16_384)
+    const denied = () => new processes_contract_1.FunctionProcessReadError(401, "invalid_context", "Completed-agent reference lookup requires an agent-read credential");
+    if (matches.length !== 1 ||
+        typeof token !== "string" ||
+        token.length > 16_384)
         throw denied();
     const body = /^([A-Za-z0-9_-]+)\.[A-Za-z0-9_-]{43}$/.exec(token)?.[1];
     if (!body)
         throw denied();
     let value;
     try {
-        value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+        value = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
     }
     catch {
         throw denied();
     }
-    const claims = zod_1.z.object({ audience: zod_1.z.literal('atlas-managed-function-agent-read'), sub: zod_1.z.string().startsWith('service-account|'), functionId: zod_1.z.string().min(1), invocationId: zod_1.z.string().min(1), exp: zod_1.z.number().int() }).safeParse(value);
+    const claims = zod_1.z
+        .object({
+        audience: zod_1.z.literal("atlas-managed-function-agent-read"),
+        sub: zod_1.z.string().startsWith("service-account|"),
+        functionId: zod_1.z.string().min(1),
+        invocationId: zod_1.z.string().min(1),
+        exp: zod_1.z.number().int(),
+    })
+        .safeParse(value);
     if (!claims.success)
         throw denied();
     return { token, expiresAt: claims.data.exp };
 }
-const invalidContext = () => new processes_contract_1.FunctionProcessReadError(401, 'invalid_context', 'This invocation has no valid process-read credential');
+const invalidContext = () => new processes_contract_1.FunctionProcessReadError(401, "invalid_context", "This invocation has no valid process-read credential");
 function createFunctionServiceProcessesClient({ request, baseUrl, fetchImpl = globalThis.fetch, }) {
     const credential = (0, invocation_client_1.readInvocationCredential)({
         request,
@@ -51,58 +65,59 @@ function createFunctionServiceProcessesClient({ request, baseUrl, fetchImpl = gl
         maxBytes: 16_384,
         invalidContext,
         claimsSchema: zod_1.z.object({
-            audience: zod_1.z.literal('atlas-managed-function-process-read'),
-            sub: zod_1.z.string().startsWith('service-account|'),
+            audience: zod_1.z.literal("atlas-managed-function-process-read"),
+            sub: zod_1.z.string().startsWith("service-account|"),
             functionId: zod_1.z.string().min(1),
             invocationId: zod_1.z.string().min(1),
             exp: zod_1.z.number().int(),
         }),
     });
-    const transport = (0, invocation_client_1.createInvocationReadTransport)({
-        baseUrl,
-        fetchImpl,
-        path: processes_contract_1.FUNCTION_PROCESS_READ_PATH,
-        header: processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER,
-        credential,
-        timeoutMs: 30_000,
-        error: (status, code, message) => new processes_contract_1.FunctionProcessReadError(status, code, message),
-        failure: { code: 'process_read_failed', message: 'Process read failed' },
-    });
-    const read = ({ body, schema }) => transport({ body: processes_contract_1.functionProcessReadRequestSchema.parse(body), schema });
+    let shared;
+    try {
+        shared = (0, browser_1.createLatticeReadClient)({
+            transport: (0, browser_1.createPlatformTransport)({
+                baseUrl,
+                fetchImpl,
+                auth: { kind: "invocation-process", token: credential.token },
+            }),
+        });
+    }
+    catch (error) {
+        if (error instanceof processes_contract_1.FunctionProcessReadError)
+            throw error;
+        if (error instanceof browser_1.PlatformError)
+            throw new processes_contract_1.FunctionProcessReadError(error.status, error.code, error.message);
+        throw error;
+    }
     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;
-        },
+        getCompletedNode: shared.completedNodes.get,
+        getRun: shared.runs.get,
+        listRunsPage: shared.runs.listPage,
         async getCompletedAgentReference(query) {
             const agent = readAgentCredential({ request });
             const readReference = (0, invocation_client_1.createInvocationReadTransport)({
-                baseUrl, fetchImpl, path: processes_contract_1.FUNCTION_PROCESS_READ_PATH, header: processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER,
-                credential, additionalCredentials: [{ header: agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER, credential: agent }],
-                timeoutMs: 30_000, error: (status, code, message) => new processes_contract_1.FunctionProcessReadError(status, code, message),
-                failure: { code: 'process_read_failed', message: 'Process read failed' },
-            });
-            return readReference({ body: processes_contract_1.functionProcessReadRequestSchema.parse({ ...query, operation: 'getCompletedAgentReference' }), schema: processes_contract_1.functionProcessCompletedAgentReferenceSchema });
-        },
-        async getRun(query) {
-            const run = await read({
-                body: { ...query, operation: 'getRun' },
-                schema: processes_contract_1.functionProcessRunSummarySchema,
+                baseUrl,
+                fetchImpl,
+                path: processes_contract_1.FUNCTION_PROCESS_READ_PATH,
+                header: processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER,
+                credential,
+                additionalCredentials: [
+                    { header: agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER, credential: agent },
+                ],
+                timeoutMs: 30_000,
+                error: (status, code, message) => new processes_contract_1.FunctionProcessReadError(status, code, message),
+                failure: {
+                    code: "process_read_failed",
+                    message: "Process read failed",
+                },
             });
-            if (run.id !== query.runId || run.processId !== query.process)
-                throw new processes_contract_1.FunctionProcessReadError(502, 'malformed_response', 'Atlas returned a different process run');
-            return run;
-        },
-        async listRunsPage(query) {
-            const page = await read({
-                body: { ...query, operation: 'listRunsPage' },
-                schema: processes_contract_1.functionProcessRunsPageSchema,
+            return readReference({
+                body: processes_contract_1.functionProcessReadRequestSchema.parse({
+                    ...query,
+                    operation: "getCompletedAgentReference",
+                }),
+                schema: processes_contract_1.functionProcessCompletedAgentReferenceSchema,
             });
-            if (page.runs.some((run) => run.processId !== query.process))
-                throw new processes_contract_1.FunctionProcessReadError(502, 'malformed_response', 'Atlas returned runs from a different process');
-            return page;
         },
     };
 }