@sequenceholdings/managed-functions 0.4.0 → 0.4.2

package/dist/agent-source-evidence-contract.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionAgentSourceEvidenceVerificationSchema = exports.functionAgentSourceEvidenceRequestSchema = exports.functionAgentSourceEvidenceClaimsSchema = exports.functionAgentHumanConversationEvidenceClaimsSchema = exports.functionAgentRunSourceEvidenceClaimsSchema = exports.functionAgentManagedFunctionSourceEvidenceClaimsSchema = exports.functionAgentHumanSourceEvidenceClaimsSchema = exports.functionAgentConversationEvidenceRequestSchema = exports.functionAgentConversationEvidenceQuerySchema = exports.functionAgentConversationEvidenceCaptureSchema = exports.functionAgentConversationEvidenceResponseSchema = exports.functionAgentSourceEvidenceCaptureSchema = exports.functionAgentSourceResponseSchema = exports.functionAgentConversationResponseSchema = exports.functionAgentSourceExecutionSchema = exports.functionSourceJobAdmissionSchema = exports.AGENT_SOURCE_VERIFY_MAX_BYTES = exports.AGENT_SOURCE_RESPONSE_MAX_BYTES = exports.FUNCTION_AGENT_EVIDENCE_PATH = exports.FUNCTION_AGENT_EVIDENCE_TOKEN_HEADER = exports.functionAgentEvidenceScopesSchema = void 0;
+exports.readFunctionAgentEvidenceScopes = readFunctionAgentEvidenceScopes;
+const zod_1 = require("zod");
+const agents_contract_1 = require("./agents-contract");
+var agents_contract_2 = require("./agents-contract");
+Object.defineProperty(exports, "functionAgentEvidenceScopesSchema", { enumerable: true, get: function () { return agents_contract_2.functionAgentEvidenceScopesSchema; } });
+exports.FUNCTION_AGENT_EVIDENCE_TOKEN_HEADER = 'x-sequence-agent-evidence-token';
+exports.FUNCTION_AGENT_EVIDENCE_PATH = '/api/managed-functions/agents/evidence';
+exports.AGENT_SOURCE_RESPONSE_MAX_BYTES = 512 * 1024;
+exports.AGENT_SOURCE_VERIFY_MAX_BYTES = 768 * 1024;
+const identifier = zod_1.z.string().min(1).max(255);
+const hash = zod_1.z.string().regex(/^[a-f0-9]{64}$/);
+exports.functionSourceJobAdmissionSchema = zod_1.z.strictObject({
+    idempotencyKey: zod_1.z.string().min(1).max(128).regex(/^[\x21-\x7e]+$/), requestHash: hash,
+    kind: zod_1.z.enum(['agent', 'workflow']), resourceId: identifier, actorSub: zod_1.z.string().min(1).max(512),
+    runId: identifier, executionSnapshotId: zod_1.z.uuid(),
+});
+exports.functionAgentSourceExecutionSchema = zod_1.z.strictObject({
+    run: zod_1.z.strictObject({ id: identifier, processId: identifier, processVersion: identifier, bundleHash: identifier, entity: zod_1.z.strictObject({ type: identifier, id: identifier }).nullable() }),
+    step: zod_1.z.strictObject({ id: identifier, nodeId: identifier, attempt: zod_1.z.number().int().positive() }),
+    agent: zod_1.z.strictObject({ id: identifier, runId: identifier, threadId: identifier, identity: zod_1.z.strictObject({ id: identifier, version: identifier, definitionSha256: hash }) }),
+}).refine((source) => source.agent.id === source.agent.identity.id, 'The source agent must match its private execution identity');
+function readFunctionAgentEvidenceScopes(manifest) {
+    if (typeof manifest !== 'object' || manifest === null)
+        return [];
+    const capabilities = Reflect.get(manifest, 'capabilities');
+    if (typeof capabilities !== 'object' || capabilities === null)
+        return [];
+    const agents = Reflect.get(capabilities, 'agents');
+    if (typeof agents !== 'object' || agents === null)
+        return [];
+    const evidence = Reflect.get(agents, 'evidence');
+    return evidence === undefined ? [] : agents_contract_1.functionAgentEvidenceScopesSchema.parse(evidence);
+}
+const textPart = zod_1.z.strictObject({ type: zod_1.z.literal('text'), text: zod_1.z.string() });
+const toolPart = zod_1.z.strictObject({
+    type: zod_1.z.string().min(1).max(255).refine((type) => type !== 'tool-result' && (type === 'dynamic-tool' || type === 'tool-invocation' || type.startsWith('tool-')), 'Only tool parts are permitted'),
+    toolName: zod_1.z.string().max(255).optional(), name: zod_1.z.string().max(255).optional(), toolCallId: identifier.optional(), state: zod_1.z.string().max(255).optional(),
+    input: zod_1.z.json().optional(), output: zod_1.z.json().optional(),
+});
+exports.functionAgentConversationResponseSchema = agents_contract_1.functionAgentCompletedRunSchema.extend({
+    context: zod_1.z.strictObject({
+        messages: zod_1.z.array(zod_1.z.strictObject({ id: identifier, role: zod_1.z.enum(['user', 'assistant']), parts: zod_1.z.array(zod_1.z.union([textPart, toolPart])).max(1000), metadata: zod_1.z.strictObject({ citations: zod_1.z.array(zod_1.z.json()).max(1000) }).optional() })).max(1000),
+        compactionSummary: zod_1.z.string().nullable(),
+    }),
+});
+exports.functionAgentSourceResponseSchema = zod_1.z.union([agents_contract_1.functionAgentCompletedRunSchema, exports.functionAgentConversationResponseSchema]);
+exports.functionAgentSourceEvidenceCaptureSchema = zod_1.z.strictObject({ response: exports.functionAgentSourceResponseSchema, responseHash: hash, sourceReceipt: zod_1.z.string().min(1).max(16_384) });
+const conversationRevision = zod_1.z.number().int().min(1).max(Number.MAX_SAFE_INTEGER);
+exports.functionAgentConversationEvidenceResponseSchema = zod_1.z.strictObject({
+    agent: identifier, threadId: identifier, revision: conversationRevision, cutoffAt: zod_1.z.iso.datetime({ offset: true }),
+    context: exports.functionAgentConversationResponseSchema.shape.context.extend({ compactionSummary: zod_1.z.null() }),
+    conversation: agents_contract_1.functionAgentCompletedRunSchema.shape.conversation.unwrap(),
+});
+exports.functionAgentConversationEvidenceCaptureSchema = zod_1.z.strictObject({ response: exports.functionAgentConversationEvidenceResponseSchema, responseHash: hash, sourceReceipt: zod_1.z.string().min(1).max(16_384) });
+exports.functionAgentConversationEvidenceQuerySchema = zod_1.z.strictObject({ agent: identifier, threadId: identifier });
+exports.functionAgentConversationEvidenceRequestSchema = exports.functionAgentConversationEvidenceQuerySchema.extend({ operation: zod_1.z.literal('verifyConversationEvidence'), response: exports.functionAgentConversationEvidenceResponseSchema, responseHash: hash, sourceReceipt: zod_1.z.string().min(1).max(16_384) });
+const sourceEvidenceFields = {
+    environment: zod_1.z.string(), org: identifier, agentId: identifier, runId: identifier, threadId: identifier,
+    familyRunIds: zod_1.z.array(identifier).min(1).max(16), cutoffAt: zod_1.z.iso.datetime({ offset: true }),
+    responseHash: hash, sourceExecution: exports.functionAgentSourceExecutionSchema.nullable(), jobAdmission: exports.functionSourceJobAdmissionSchema.nullable(),
+};
+exports.functionAgentHumanSourceEvidenceClaimsSchema = zod_1.z.strictObject({
+    ...sourceEvidenceFields, sourceKind: zod_1.z.literal('human'), audience: zod_1.z.literal('atlas-agent-source-evidence'),
+    actualUserSub: zod_1.z.string().min(1).max(512).refine((sub) => !sub.startsWith('service-account|'), 'Human source evidence requires a user principal'),
+    projection: zod_1.z.enum(['completed-v1', 'conversation-v1']),
+});
+exports.functionAgentManagedFunctionSourceEvidenceClaimsSchema = zod_1.z.strictObject({
+    ...sourceEvidenceFields, sourceKind: zod_1.z.literal('managed_function'), audience: zod_1.z.literal('atlas-managed-function-source-evidence'),
+    actualServiceAccountSub: zod_1.z.string().min(1).max(512), projection: zod_1.z.literal('completed-v1'),
+    sourceReceiver: zod_1.z.strictObject({ functionId: zod_1.z.uuid(), versionId: zod_1.z.uuid(), invocationId: zod_1.z.uuid(), serviceAccountId: zod_1.z.uuid(), org: identifier }),
+}).refine((source) => source.actualServiceAccountSub === `service-account|${source.sourceReceiver.serviceAccountId}` && source.org === source.sourceReceiver.org, 'The service source must match its actual invocation identity');
+exports.functionAgentRunSourceEvidenceClaimsSchema = zod_1.z.discriminatedUnion('sourceKind', [exports.functionAgentHumanSourceEvidenceClaimsSchema, exports.functionAgentManagedFunctionSourceEvidenceClaimsSchema])
+    .refine((source) => source.familyRunIds.includes(source.runId) && new Set(source.familyRunIds).size === source.familyRunIds.length, 'The source family must contain its run and be distinct')
+    .refine((source) => source.sourceExecution === null || (source.sourceExecution.agent.id === source.agentId && source.sourceExecution.agent.runId === source.runId && source.sourceExecution.agent.threadId === source.threadId), 'The execution origin must match the captured source')
+    .refine((source) => source.jobAdmission === null || (source.jobAdmission.kind === 'agent' && source.jobAdmission.runId === source.runId && source.jobAdmission.resourceId === source.agentId && (source.sourceKind === 'human' || source.jobAdmission.actorSub === source.actualServiceAccountSub)), 'The job admission must match the captured source');
+exports.functionAgentHumanConversationEvidenceClaimsSchema = zod_1.z.strictObject({
+    sourceKind: zod_1.z.literal('human'), projection: zod_1.z.literal('thread-conversation-v1'), audience: zod_1.z.literal('atlas-agent-source-evidence'),
+    actualUserSub: zod_1.z.string().min(1).max(512).refine((sub) => !sub.startsWith('service-account|'), 'Human conversation evidence requires a user principal'),
+    environment: zod_1.z.string(), org: identifier, agentId: identifier, threadId: identifier,
+    revision: conversationRevision, cutoffAt: zod_1.z.iso.datetime({ offset: true }), responseHash: hash,
+});
+exports.functionAgentSourceEvidenceClaimsSchema = zod_1.z.union([exports.functionAgentRunSourceEvidenceClaimsSchema, exports.functionAgentHumanConversationEvidenceClaimsSchema]);
+exports.functionAgentSourceEvidenceRequestSchema = zod_1.z.strictObject({ operation: zod_1.z.literal('verifySourceEvidence'), agent: identifier, runId: identifier, response: exports.functionAgentSourceResponseSchema, responseHash: hash, sourceReceipt: zod_1.z.string().min(1).max(16_384) });
+exports.functionAgentSourceEvidenceVerificationSchema = zod_1.z.strictObject({
+    source: exports.functionAgentSourceEvidenceClaimsSchema,
+    receiver: zod_1.z.strictObject({ functionId: identifier, versionId: identifier, invocationId: identifier, serviceAccountId: identifier, org: identifier }),
+    lattice: zod_1.z.strictObject({
+        receiverFunctionOrgId: identifier,
+        run: zod_1.z.strictObject({ id: identifier, processId: identifier, processVersion: identifier, bundleHash: identifier, entity: zod_1.z.strictObject({ type: identifier, id: identifier }).nullable() }),
+        step: zod_1.z.strictObject({ id: identifier, nodeId: identifier, attempt: zod_1.z.number().int().positive(), runAsServiceAccount: zod_1.z.string().nullable() }),
+        receiver: zod_1.z.strictObject({ functionId: identifier, versionId: identifier, invocationId: identifier }),
+    }).nullable(),
+});

package/dist/agents-contract.d.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+export declare const FUNCTION_AGENT_TOKEN_HEADER = "x-sequence-agent-service-token";
+export declare const FUNCTION_AGENT_READ_PATH = "/api/managed-functions/agents/read";
+export declare const FUNCTION_AGENT_CAPTURE_PATH = "/api/managed-functions/agents/capture";
+export declare const functionAgentEvidenceScopesSchema: z.ZodArray<z.ZodString>;
+export declare const functionAgentReadScopesSchema: z.ZodObject<{
+    read: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    evidence: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+export declare function readFunctionAgentScopes(manifest: unknown): string[];
+export declare const functionAgentCompletedRunQuerySchema: z.ZodObject<{
+    agent: z.ZodString;
+    runId: z.ZodString;
+    recoveryProof: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type FunctionAgentCompletedRunQuery = z.infer<typeof functionAgentCompletedRunQuerySchema>;
+export declare const functionAgentReadRequestSchema: z.ZodObject<{
+    agent: z.ZodString;
+    runId: z.ZodString;
+    recoveryProof: z.ZodOptional<z.ZodString>;
+    operation: z.ZodLiteral<"getCompletedRun">;
+}, z.core.$strict>;
+export declare const functionAgentMessageSchema: z.ZodObject<{
+    id: z.ZodString;
+    role: z.ZodLiteral<"assistant">;
+    parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        type: z.ZodLiteral<"text">;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        type: z.ZodLiteral<"dynamic-tool">;
+        output: z.ZodObject<{
+            content: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"resource">;
+                resource: z.ZodObject<{
+                    uri: z.ZodString;
+                    text: z.ZodString;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>;
+    metadata: z.ZodOptional<z.ZodObject<{
+        citations: z.ZodArray<z.ZodJSONSchema>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const functionAgentCompletedRunSchema: z.ZodObject<{
+    runId: z.ZodString;
+    agent: z.ZodString;
+    threadId: z.ZodString;
+    status: z.ZodLiteral<"completed">;
+    output: z.ZodJSONSchema;
+    messages: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        role: z.ZodLiteral<"assistant">;
+        parts: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            type: z.ZodLiteral<"text">;
+            text: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"dynamic-tool">;
+            output: z.ZodObject<{
+                content: z.ZodArray<z.ZodObject<{
+                    type: z.ZodLiteral<"resource">;
+                    resource: z.ZodObject<{
+                        uri: z.ZodString;
+                        text: z.ZodString;
+                    }, z.core.$strict>;
+                }, z.core.$strict>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>]>>;
+        metadata: z.ZodOptional<z.ZodObject<{
+            citations: z.ZodArray<z.ZodJSONSchema>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    conversation: z.ZodOptional<z.ZodObject<{
+        messageCount: z.ZodNumber;
+        userMessageCount: z.ZodNumber;
+        assistantMessageCount: z.ZodNumber;
+        messages: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            role: z.ZodEnum<{
+                assistant: "assistant";
+                user: "user";
+            }>;
+            textParts: z.ZodArray<z.ZodString>;
+            tools: z.ZodArray<z.ZodObject<{
+                partType: z.ZodString;
+                toolName: z.ZodNullable<z.ZodString>;
+                state: z.ZodNullable<z.ZodString>;
+                outputTruthy: z.ZodBoolean;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type FunctionAgentCompletedRun = z.infer<typeof functionAgentCompletedRunSchema>;
+export declare class FunctionAgentReadError extends Error {
+    readonly status: number;
+    readonly code: string;
+    readonly name = "FunctionAgentReadError";
+    constructor(status: number, code: string, message: string);
+}

package/dist/agents-contract.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionAgentReadError = exports.functionAgentCompletedRunSchema = exports.functionAgentMessageSchema = exports.functionAgentReadRequestSchema = exports.functionAgentCompletedRunQuerySchema = exports.functionAgentReadScopesSchema = exports.functionAgentEvidenceScopesSchema = exports.FUNCTION_AGENT_CAPTURE_PATH = exports.FUNCTION_AGENT_READ_PATH = exports.FUNCTION_AGENT_TOKEN_HEADER = void 0;
+exports.readFunctionAgentScopes = readFunctionAgentScopes;
+const zod_1 = require("zod");
+exports.FUNCTION_AGENT_TOKEN_HEADER = 'x-sequence-agent-service-token';
+exports.FUNCTION_AGENT_READ_PATH = '/api/managed-functions/agents/read';
+exports.FUNCTION_AGENT_CAPTURE_PATH = '/api/managed-functions/agents/capture';
+const resourceId = zod_1.z.string().min(1).max(255).regex(/^[A-Za-z0-9._-]+$/);
+exports.functionAgentEvidenceScopesSchema = zod_1.z.array(resourceId).min(1).max(64)
+    .refine((ids) => new Set(ids).size === ids.length, 'Agent evidence ids must be distinct')
+    .refine((ids) => ids.reduce((bytes, id) => bytes + id.length, 0) <= 8192, 'Agent evidence ids must fit within 8192 bytes');
+exports.functionAgentReadScopesSchema = zod_1.z.strictObject({
+    read: zod_1.z.array(resourceId).min(1).max(64)
+        .refine((ids) => new Set(ids).size === ids.length, 'Agent ids must be distinct')
+        .refine((ids) => ids.reduce((bytes, id) => bytes + id.length, 0) <= 8192, 'Agent ids must fit within 8192 bytes').optional(),
+    evidence: exports.functionAgentEvidenceScopesSchema.optional(),
+}).refine((value) => value.read !== undefined || value.evidence !== undefined, 'Declare agent reads or evidence verification');
+function readFunctionAgentScopes(manifest) {
+    if (typeof manifest !== 'object' || manifest === null)
+        return [];
+    const capabilities = Reflect.get(manifest, 'capabilities');
+    if (typeof capabilities !== 'object' || capabilities === null)
+        return [];
+    const agents = Reflect.get(capabilities, 'agents');
+    if (agents === undefined)
+        return [];
+    return exports.functionAgentReadScopesSchema.parse(agents).read ?? [];
+}
+exports.functionAgentCompletedRunQuerySchema = zod_1.z.strictObject({ agent: resourceId, runId: resourceId, recoveryProof: zod_1.z.string().min(1).max(16_384).optional() });
+exports.functionAgentReadRequestSchema = exports.functionAgentCompletedRunQuerySchema.extend({ operation: zod_1.z.literal('getCompletedRun') });
+exports.functionAgentMessageSchema = zod_1.z.strictObject({
+    id: zod_1.z.string().min(1).max(255),
+    role: zod_1.z.literal('assistant'),
+    parts: zod_1.z.array(zod_1.z.union([
+        zod_1.z.strictObject({ type: zod_1.z.literal('text'), text: zod_1.z.string() }),
+        zod_1.z.strictObject({ type: zod_1.z.literal('dynamic-tool'), output: zod_1.z.strictObject({ content: zod_1.z.array(zod_1.z.strictObject({ type: zod_1.z.literal('resource'), resource: zod_1.z.strictObject({ uri: zod_1.z.string().startsWith('citation://'), text: zod_1.z.string() }) })).max(1000) }) }),
+    ])).max(1000),
+    metadata: zod_1.z.strictObject({ citations: zod_1.z.array(zod_1.z.json()).max(1000) }).optional(),
+});
+exports.functionAgentCompletedRunSchema = zod_1.z.strictObject({
+    runId: resourceId,
+    agent: resourceId,
+    threadId: resourceId,
+    status: zod_1.z.literal('completed'),
+    output: zod_1.z.json(),
+    messages: zod_1.z.array(exports.functionAgentMessageSchema).max(1000),
+    conversation: zod_1.z.strictObject({
+        messageCount: zod_1.z.number().int().min(0).max(1000),
+        userMessageCount: zod_1.z.number().int().min(0).max(1000),
+        assistantMessageCount: zod_1.z.number().int().min(0).max(1000),
+        messages: zod_1.z.array(zod_1.z.strictObject({
+            id: zod_1.z.string().min(1).max(255), role: zod_1.z.enum(['user', 'assistant']),
+            textParts: zod_1.z.array(zod_1.z.string()).max(1000),
+            tools: zod_1.z.array(zod_1.z.strictObject({ partType: zod_1.z.string().min(1).max(255), toolName: zod_1.z.string().max(255).nullable(), state: zod_1.z.string().max(255).nullable(), outputTruthy: zod_1.z.boolean() })).max(1000),
+        })).max(1000),
+    }).optional(),
+});
+class FunctionAgentReadError extends Error {
+    status;
+    code;
+    name = 'FunctionAgentReadError';
+    constructor(status, code, message) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+exports.FunctionAgentReadError = FunctionAgentReadError;

package/dist/agents.d.ts

@@ -0,0 +1,15 @@
+import { type FunctionAgentCompletedRun, type FunctionAgentCompletedRunQuery } from './agents-contract';
+import { type FunctionAgentSourceEvidenceCapture } from './agent-source-evidence-contract';
+export * from './agents-contract';
+export interface FunctionServiceAgentsOptions {
+    request: {
+        headers: Pick<Headers, 'get'> | Readonly<Record<string, string | readonly string[] | undefined>>;
+    };
+    baseUrl: string;
+    fetchImpl?: typeof globalThis.fetch;
+}
+export interface FunctionServiceAgentsClient {
+    getCompletedRun(query: FunctionAgentCompletedRunQuery): Promise<FunctionAgentCompletedRun>;
+    captureCompletedRun(query: FunctionAgentCompletedRunQuery): Promise<FunctionAgentSourceEvidenceCapture>;
+}
+export declare function createFunctionServiceAgentsClient({ request, baseUrl, fetchImpl }: FunctionServiceAgentsOptions): FunctionServiceAgentsClient;

package/dist/agents.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFunctionServiceAgentsClient = createFunctionServiceAgentsClient;
+const zod_1 = require("zod");
+const agents_contract_1 = require("./agents-contract");
+const agent_source_evidence_contract_1 = require("./agent-source-evidence-contract");
+const processes_contract_1 = require("./processes-contract");
+__exportStar(require("./agents-contract"), exports);
+function header({ request, name }) {
+    const { headers } = request;
+    const values = typeof headers.get === 'function' ? [headers.get(name)] : Object.entries(headers).filter(([key]) => key.toLowerCase() === name).map(([, value]) => value);
+    return values.length === 1 && typeof values[0] === 'string' ? values[0] : null;
+}
+function credential(request) {
+    const denied = () => new agents_contract_1.FunctionAgentReadError(401, 'invalid_context', 'This invocation has no valid agent-read credential');
+    const token = header({ request, name: agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER });
+    if (!token || 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'));
+    }
+    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);
+    if (!claims.success)
+        throw denied();
+    return { token, expiresAt: claims.data.exp };
+}
+function origin(baseUrl) {
+    let url;
+    try {
+        url = new URL(baseUrl);
+    }
+    catch {
+        throw new agents_contract_1.FunctionAgentReadError(400, 'invalid_configuration', 'Configure a trusted Atlas origin');
+    }
+    const loopback = url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname);
+    if ((!loopback && url.protocol !== 'https:') || url.username || url.password || url.pathname !== '/' || url.search || url.hash)
+        throw new agents_contract_1.FunctionAgentReadError(400, 'invalid_configuration', 'Configure an HTTPS Atlas origin without credentials, path, query or fragment');
+    return url.origin;
+}
+function recoveryProcessCredential(request) {
+    const denied = () => new agents_contract_1.FunctionAgentReadError(401, 'invalid_context', 'Recovery requires this invocation’s process-read credential');
+    const token = header({ request, name: processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER });
+    if (!token || 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'));
+    }
+    catch {
+        throw denied();
+    }
+    const claims = zod_1.z.object({ 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() }).safeParse(value);
+    if (!claims.success)
+        throw denied();
+    if (claims.data.exp <= Date.now() / 1000)
+        throw new agents_contract_1.FunctionAgentReadError(401, 'expired_context', 'The process-read credential expired; start a new invocation');
+    return token;
+}
+function createFunctionServiceAgentsClient({ request, baseUrl, fetchImpl = globalThis.fetch }) {
+    const base = origin(baseUrl);
+    const { token, expiresAt } = credential(request);
+    const lattice = header({ request, name: 'x-sequence-lattice-execution-token' });
+    async function read(query, capture) {
+        if (expiresAt <= Date.now() / 1000)
+            throw new agents_contract_1.FunctionAgentReadError(401, 'expired_context', 'The agent-read credential expired; start a new invocation');
+        const body = agents_contract_1.functionAgentCompletedRunQuerySchema.parse(query);
+        const process = body.recoveryProof ? recoveryProcessCredential(request) : null;
+        const evidence = capture ? header({ request, name: agent_source_evidence_contract_1.FUNCTION_AGENT_EVIDENCE_TOKEN_HEADER }) : null;
+        if (capture && !evidence)
+            throw new agents_contract_1.FunctionAgentReadError(401, 'invalid_context', 'Source capture requires this invocation’s separate agent-evidence credential');
+        const response = await fetchImpl(`${base}${capture ? agents_contract_1.FUNCTION_AGENT_CAPTURE_PATH : agents_contract_1.FUNCTION_AGENT_READ_PATH}`, {
+            method: 'POST', headers: { 'content-type': 'application/json', [agents_contract_1.FUNCTION_AGENT_TOKEN_HEADER]: token, ...(process ? { [processes_contract_1.FUNCTION_PROCESS_TOKEN_HEADER]: process } : {}), ...(evidence ? { [agent_source_evidence_contract_1.FUNCTION_AGENT_EVIDENCE_TOKEN_HEADER]: evidence } : {}), ...(lattice ? { 'x-sequence-lattice-execution-token': lattice } : {}) },
+            body: JSON.stringify({ ...body, operation: capture ? 'captureCompletedRun' : 'getCompletedRun' }), redirect: 'error', signal: AbortSignal.timeout(30_000),
+        });
+        const result = await response.json().catch(() => null);
+        if (!response.ok) {
+            const error = zod_1.z.object({ code: zod_1.z.string().max(128).optional(), detail: zod_1.z.string().max(2000).optional() }).safeParse(result);
+            throw new agents_contract_1.FunctionAgentReadError(response.status, error.success ? (error.data.code ?? 'agent_read_failed') : 'agent_read_failed', error.success ? (error.data.detail ?? 'Agent read failed') : 'Agent read failed');
+        }
+        return result;
+    }
+    return {
+        async getCompletedRun(query) {
+            const result = await read(query, false);
+            const parsed = agents_contract_1.functionAgentCompletedRunSchema.safeParse(result);
+            if (!parsed.success || parsed.data.runId !== query.runId || parsed.data.agent !== query.agent)
+                throw new agents_contract_1.FunctionAgentReadError(502, 'malformed_response', 'Atlas returned an invalid completed agent response');
+            return parsed.data;
+        },
+        async captureCompletedRun(query) {
+            const parsed = agent_source_evidence_contract_1.functionAgentSourceEvidenceCaptureSchema.safeParse(await read(query, true));
+            if (!parsed.success || parsed.data.response.runId !== query.runId || parsed.data.response.agent !== query.agent || 'context' in parsed.data.response)
+                throw new agents_contract_1.FunctionAgentReadError(502, 'malformed_response', 'Atlas returned an invalid neutral source capture');
+            return parsed.data;
+        },
+    };
+}

package/dist/capabilities.d.ts

@@ -13,6 +13,83 @@ export declare const MANAGED_FUNCTION_CAPABILITIES: {
         };
     };
     readonly features: {
+        readonly directory_members: {
+            readonly field: "capabilities.directory.groups";
+            readonly supported: true;
+            readonly limit: "1 to 16 concrete groups; resolve 1 to 50 selected active members per call";
+            readonly min_cli: "0.5.2";
+            readonly min_sdk: "0.4.1";
+        };
+        readonly abrigo_read: {
+            readonly field: "capabilities.abrigo.read";
+            readonly supported: true;
+            readonly limit: "eleven fixed human reads: eight integration reads and three workflow-scoped document-review reads; pages 1 to 100 with 1 to 500 rows; 1 MiB JSON responses";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly immutable_release: {
+            readonly field: "function.immutable_release";
+            readonly supported: true;
+            readonly limit: "a fresh function identity whose runtime cannot be redeployed after first activation";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly invocation_identity: {
+            readonly field: "capabilities.invocation.identity";
+            readonly supported: true;
+            readonly limit: "verified receiver and actual caller for this exact active invocation only";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly directory_resolve: {
+            readonly field: "capabilities.directory.resolve";
+            readonly supported: true;
+            readonly limit: "1 to 16 exact tenant scopes; at most 50 exact active human principal lookups";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly lattice_context: {
+            readonly field: "capabilities.lattice.context";
+            readonly supported: true;
+            readonly limit: "verified context and causal human completion for the receiving Lattice step only";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly agents_read: {
+            readonly field: "capabilities.agents.read";
+            readonly supported: true;
+            readonly limit: "1 to 64 exact agent ids; completed owned or verified upstream responses only";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly agents_evidence_verify: {
+            readonly field: "capabilities.agents.evidence";
+            readonly supported: true;
+            readonly limit: "1 to 64 exact agent ids; verify bounded supplied historical source evidence only";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly workflows_read: {
+            readonly field: "capabilities.workflows.read";
+            readonly supported: true;
+            readonly limit: "1 to 64 exact workflow ids; completed owned root outputs only";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly workflows_evidence_verify: {
+            readonly field: "capabilities.workflows.evidence";
+            readonly supported: true;
+            readonly limit: "1 to 64 exact workflow ids; verify bounded supplied historical root-output evidence only";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
+        readonly monitoring_deliveries: {
+            readonly field: "capabilities.monitoring.producers";
+            readonly supported: true;
+            readonly limit: "1 to 16 producer namespaces; immutable publish and receipt lookup";
+            readonly min_cli: "0.5.5";
+            readonly min_sdk: "0.4.2";
+        };
         readonly processes_read: {
             readonly field: "capabilities.processes.read";
             readonly supported: true;
@@ -57,6 +134,83 @@ export interface CapabilityTooling {
 export interface ManagedFunctionCapabilities {
     tooling: CapabilityTooling;
     features: {
+        directory_members?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        abrigo_read?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        immutable_release?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        invocation_identity?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        directory_resolve?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        lattice_context?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        agents_read?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        agents_evidence_verify?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        workflows_read?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        workflows_evidence_verify?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
+        monitoring_deliveries?: {
+            field: string;
+            supported: boolean;
+            limit: string;
+            min_cli: string;
+            min_sdk: string;
+        };
         processes_read?: {
             field: string;
             supported: boolean;
@@ -93,6 +247,9 @@ export interface DeployedPolicy {
     capabilities: ManagedFunctionCapabilities | null;
 }
 export interface PreflightManifest {
+    function?: {
+        immutable_release?: unknown;
+    };
     limits?: {
         memory_mb?: number;
         cpu?: number | 'auto';
@@ -108,6 +265,13 @@ export interface PreflightManifest {
         data?: Readonly<Record<string, unknown>>;
         storage?: unknown;
         processes?: unknown;
+        agents?: unknown;
+        workflows?: unknown;
+        monitoring?: unknown;
+        directory?: unknown;
+        abrigo?: unknown;
+        lattice?: unknown;
+        invocation?: unknown;
     };
 }
 export interface PreflightIssue {
@@ -120,6 +284,7 @@ export interface PreflightIssue {
 export declare function versionIsOlder(installed: string, required: string): boolean;
 export declare function sdkVersionLowerBound(spec: string | undefined): string | null;
 export declare function sdkVersionFromPackageJson(raw: string): string | null;
+export declare function sdkSpecFromPackageJson(raw: string): string | null;
 export declare function isPostgresEgress(entry: string): boolean;
 export declare function formatValidationDetail(issues: readonly {
     path?: readonly PropertyKey[];