@datalayer/core 1.1.60 → 1.2.10

package/lib/api/orchestration/generated.js

@@ -0,0 +1,687 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+export const ORCHESTRATION_LIFECYCLE = {
+    initial: 'created',
+    states: [
+        'created',
+        'assigned',
+        'running',
+        'waiting',
+        'paused',
+        'retrying',
+        'completed',
+        'failed',
+        'cancelled',
+        'terminated',
+    ],
+    terminal: ['completed', 'failed', 'cancelled', 'terminated'],
+    events: [
+        'assign',
+        'start',
+        'wait',
+        'pause',
+        'resume',
+        'retry',
+        'complete',
+        'fail',
+        'cancel',
+        'terminate',
+    ],
+    transitions: {
+        created: {
+            cancel: 'cancelled',
+            terminate: 'terminated',
+            fail: 'failed',
+            assign: 'assigned',
+        },
+        assigned: {
+            cancel: 'cancelled',
+            terminate: 'terminated',
+            fail: 'failed',
+            start: 'running',
+            retry: 'retrying',
+        },
+        running: {
+            cancel: 'cancelled',
+            terminate: 'terminated',
+            fail: 'failed',
+            wait: 'waiting',
+            pause: 'paused',
+            retry: 'retrying',
+            complete: 'completed',
+        },
+        waiting: {
+            cancel: 'cancelled',
+            terminate: 'terminated',
+            fail: 'failed',
+            resume: 'running',
+            retry: 'retrying',
+        },
+        paused: {
+            cancel: 'cancelled',
+            terminate: 'terminated',
+            fail: 'failed',
+            resume: 'running',
+        },
+        retrying: {
+            cancel: 'cancelled',
+            terminate: 'terminated',
+            fail: 'failed',
+            start: 'running',
+        },
+        completed: {},
+        failed: {},
+        cancelled: {},
+        terminated: {},
+    },
+};
+export const ORCHESTRATION_COMMANDS = [
+    { name: 'agents.discover', mutating: false },
+    { name: 'agents.create', mutating: true },
+    { name: 'agents.attach', mutating: true },
+    { name: 'executions.delegate', mutating: true },
+    { name: 'executions.steer', mutating: true },
+    { name: 'executions.pause', mutating: true },
+    { name: 'executions.resume', mutating: true },
+    { name: 'executions.cancel', mutating: true },
+    { name: 'executions.checkpoint', mutating: true },
+    { name: 'executions.collect', mutating: false },
+    { name: 'executions.terminate', mutating: true },
+    { name: 'executions.subscribe', mutating: false },
+];
+/** The five milestones of section 6.3, in the order they are reached. */
+export const ORCHESTRATION_ACKNOWLEDGEMENT_ORDER = ['received', 'accepted', 'started', 'checkpointed', 'completed'];
+export const ORCHESTRATION_LIMITS = {
+    delegation: {
+        maxDepth: 3,
+        maxChildrenPerParent: 8,
+        maxExecutionsPerTree: 32,
+    },
+    retry: {
+        maxRetries: 2,
+        initialBackoffSeconds: 1.0,
+        backoffMultiplier: 2.0,
+        maxBackoffSeconds: 60.0,
+    },
+};
+export const ORCHESTRATION_FIELDS = {
+    Acknowledgement: {
+        required: ['acknowledgedAt', 'executionId', 'kind'],
+        optional: [
+            'attemptId',
+            'checkpointId',
+            'command',
+            'detail',
+            'idempotencyKey',
+        ],
+        refs: {},
+    },
+    AgentAuthentication: {
+        required: [],
+        optional: ['audience', 'schemes', 'scopes'],
+        refs: {},
+    },
+    AgentBinding: {
+        required: ['agentId', 'capability', 'protocol'],
+        optional: ['endpoint', 'sessionId'],
+        refs: {},
+    },
+    AgentCardMapping: {
+        required: ['card'],
+        optional: ['gaps'],
+        refs: { gaps: 'MappingGap' },
+    },
+    AgentDescriptor: {
+        required: ['agentId', 'name'],
+        optional: [
+            'authentication',
+            'availability',
+            'capabilities',
+            'cost',
+            'dataClassifications',
+            'description',
+            'endpoints',
+            'inputContentTypes',
+            'latency',
+            'outputContentTypes',
+            'runtime',
+            'skills',
+            'supportedOperations',
+            'trustLevel',
+            'version',
+        ],
+        refs: {
+            authentication: 'AgentAuthentication',
+            availability: 'Availability',
+            cost: 'CostHint',
+            endpoints: 'ProtocolEndpoint',
+            latency: 'LatencyHint',
+            runtime: 'RuntimeRequirements',
+            skills: 'AgentSkill',
+        },
+    },
+    AgentSkill: {
+        required: ['id', 'name'],
+        optional: ['description', 'examples', 'tags'],
+        refs: {},
+    },
+    AgentsAttach: {
+        required: ['agentId', 'idempotencyKey', 'protocol'],
+        optional: ['command', 'endpoint', 'issuedAt', 'sessionId', 'traceparent'],
+        refs: {},
+    },
+    AgentsCreate: {
+        required: ['agentId', 'idempotencyKey', 'protocol'],
+        optional: ['command', 'executionId', 'issuedAt', 'runtime', 'traceparent'],
+        refs: { runtime: 'RuntimeRequirements' },
+    },
+    AgentsDiscover: {
+        required: [],
+        optional: [
+            'capabilities',
+            'command',
+            'dataClassification',
+            'issuedAt',
+            'limit',
+            'minimumTrustLevel',
+            'operations',
+            'protocols',
+            'region',
+            'traceparent',
+        ],
+        refs: {},
+    },
+    Artifact: {
+        required: ['artifactId', 'name', 'type'],
+        optional: [
+            'committedBy',
+            'mediaType',
+            'provenance',
+            'reference',
+            'sizeBytes',
+            'status',
+            'summary',
+            'supersededBy',
+        ],
+        refs: { provenance: 'ArtifactProvenance' },
+    },
+    ArtifactCommit: {
+        required: ['attemptId', 'executionId', 'winningAttemptId', 'won'],
+        optional: ['artifacts'],
+        refs: { artifacts: 'Artifact' },
+    },
+    ArtifactProvenance: {
+        required: ['agentId', 'attemptId', 'executionId', 'producedAt'],
+        optional: ['contentHash', 'sourceReferences', 'traceId'],
+        refs: {},
+    },
+    Attempt: {
+        required: ['agentId', 'attemptId', 'executionId', 'number', 'protocol'],
+        optional: [
+            'endedAt',
+            'error',
+            'leaseExpiresAt',
+            'protocolTaskId',
+            'resumedFrom',
+            'sessionId',
+            'startedAt',
+            'state',
+            'usage',
+        ],
+        refs: { error: 'OrchestrationError', usage: 'Usage' },
+    },
+    Availability: {
+        required: [],
+        optional: ['available', 'maxConcurrentExecutions', 'queueDepth'],
+        refs: {},
+    },
+    Budget: {
+        required: [],
+        optional: [
+            'cost',
+            'credits',
+            'currency',
+            'executions',
+            'inputTokens',
+            'outputTokens',
+            'wallClockSeconds',
+        ],
+        refs: {},
+    },
+    CancelAnswer: {
+        required: ['acknowledgement', 'delivered', 'execution'],
+        optional: ['cancelledExecutionIds', 'detail', 'success'],
+        refs: { acknowledgement: 'Acknowledgement', execution: 'Execution' },
+    },
+    CollectAnswer: {
+        required: ['artifacts', 'execution'],
+        optional: ['attempts', 'children', 'success'],
+        refs: {
+            artifacts: 'Artifact',
+            attempts: 'Attempt',
+            children: 'Execution',
+            execution: 'Execution',
+        },
+    },
+    Command: {
+        required: ['command'],
+        optional: ['issuedAt', 'traceparent'],
+        refs: {},
+    },
+    CommandAnswer: {
+        required: ['acknowledgement', 'delivered', 'execution'],
+        optional: ['detail', 'success'],
+        refs: { acknowledgement: 'Acknowledgement', execution: 'Execution' },
+    },
+    ContextManifest: {
+        required: [],
+        optional: ['expiresAt', 'references', 'scope'],
+        refs: { references: 'ContextReference' },
+    },
+    ContextReference: {
+        required: ['uri'],
+        optional: [
+            'access',
+            'description',
+            'materialization',
+            'required',
+            'sharing',
+        ],
+        refs: {},
+    },
+    CostHint: {
+        required: [],
+        optional: ['currency', 'perExecution', 'perInputToken', 'perOutputToken'],
+        refs: {},
+    },
+    DelegateAnswer: {
+        required: ['acknowledgement', 'dispatched', 'execution'],
+        optional: ['detail', 'success'],
+        refs: { acknowledgement: 'Acknowledgement', execution: 'Execution' },
+    },
+    DelegationLimits: {
+        required: [],
+        optional: ['maxChildrenPerParent', 'maxDepth', 'maxExecutionsPerTree'],
+        refs: {},
+    },
+    DescriptorMapping: {
+        required: ['descriptor', 'source'],
+        optional: ['gaps'],
+        refs: { descriptor: 'AgentDescriptor', gaps: 'MappingGap' },
+    },
+    DiscoverAnswer: {
+        required: ['agents'],
+        optional: ['success'],
+        refs: { agents: 'AgentDescriptor' },
+    },
+    Execution: {
+        required: [
+            'agent',
+            'createdAt',
+            'executionId',
+            'objective',
+            'rootExecutionId',
+            'updatedAt',
+        ],
+        optional: [
+            'attemptCount',
+            'context',
+            'currentAttemptId',
+            'depth',
+            'error',
+            'parentExecutionId',
+            'policy',
+            'recovery',
+            'status',
+            'statusMessage',
+            'trace',
+        ],
+        refs: {
+            agent: 'AgentBinding',
+            context: 'ContextManifest',
+            error: 'OrchestrationError',
+            objective: 'Objective',
+            policy: 'Policy',
+            recovery: 'Recovery',
+            trace: 'Trace',
+        },
+    },
+    ExecutionAnswer: {
+        required: ['acknowledgements', 'attempts', 'execution'],
+        optional: ['success'],
+        refs: {
+            acknowledgements: 'Acknowledgement',
+            attempts: 'Attempt',
+            execution: 'Execution',
+        },
+    },
+    ExecutionEvent: {
+        required: [
+            'emittedAt',
+            'eventId',
+            'executionId',
+            'rootExecutionId',
+            'sequence',
+            'type',
+        ],
+        optional: [
+            'acknowledgement',
+            'agentId',
+            'approvalUid',
+            'artifact',
+            'attemptId',
+            'data',
+            'error',
+            'lifecycleEvent',
+            'message',
+            'parentExecutionId',
+            'previousState',
+            'protocol',
+            'sessionId',
+            'state',
+            'traceparent',
+        ],
+        refs: {
+            acknowledgement: 'Acknowledgement',
+            artifact: 'Artifact',
+            error: 'OrchestrationError',
+        },
+    },
+    ExecutionSummary: {
+        required: [
+            'agentId',
+            'depth',
+            'executionId',
+            'goal',
+            'protocol',
+            'status',
+            'updatedAt',
+        ],
+        optional: ['parentExecutionId'],
+        refs: {},
+    },
+    ExecutionsAnswer: {
+        required: ['executions'],
+        optional: ['success'],
+        refs: { executions: 'Execution' },
+    },
+    ExecutionsCancel: {
+        required: ['executionId', 'idempotencyKey'],
+        optional: ['cascade', 'command', 'issuedAt', 'reason', 'traceparent'],
+        refs: {},
+    },
+    ExecutionsCheckpoint: {
+        required: ['executionId', 'idempotencyKey'],
+        optional: ['command', 'issuedAt', 'label', 'traceparent'],
+        refs: {},
+    },
+    ExecutionsCollect: {
+        required: ['executionId'],
+        optional: [
+            'artifactTypes',
+            'command',
+            'includeChildren',
+            'issuedAt',
+            'traceparent',
+        ],
+        refs: {},
+    },
+    ExecutionsDelegate: {
+        required: ['agent', 'idempotencyKey', 'objective'],
+        optional: [
+            'command',
+            'context',
+            'issuedAt',
+            'parentExecutionId',
+            'policy',
+            'recovery',
+            'slot',
+            'trace',
+            'traceparent',
+        ],
+        refs: {
+            agent: 'AgentBinding',
+            context: 'ContextManifest',
+            objective: 'Objective',
+            policy: 'Policy',
+            recovery: 'Recovery',
+            trace: 'Trace',
+        },
+    },
+    ExecutionsPause: {
+        required: ['executionId', 'idempotencyKey'],
+        optional: ['command', 'issuedAt', 'reason', 'traceparent'],
+        refs: {},
+    },
+    ExecutionsResume: {
+        required: ['executionId', 'idempotencyKey'],
+        optional: ['checkpointId', 'command', 'issuedAt', 'traceparent'],
+        refs: {},
+    },
+    ExecutionsSteer: {
+        required: ['executionId', 'idempotencyKey', 'instructions'],
+        optional: ['command', 'issuedAt', 'references', 'traceparent'],
+        refs: { references: 'ContextReference' },
+    },
+    ExecutionsSubscribe: {
+        required: ['executionId'],
+        optional: [
+            'command',
+            'events',
+            'fromSequence',
+            'includeChildren',
+            'issuedAt',
+            'traceparent',
+        ],
+        refs: {},
+    },
+    ExecutionsTerminate: {
+        required: ['executionId', 'idempotencyKey'],
+        optional: ['command', 'issuedAt', 'reason', 'releaseWorker', 'traceparent'],
+        refs: {},
+    },
+    LatencyHint: {
+        required: [],
+        optional: ['acceptanceP50Ms', 'completionP50Ms', 'completionP95Ms'],
+        refs: {},
+    },
+    ManifestResolution: {
+        required: [],
+        optional: ['errors', 'references', 'usable'],
+        refs: { errors: 'OrchestrationError', references: 'ReferenceResolution' },
+    },
+    MappingGap: { required: ['field', 'reason'], optional: [], refs: {} },
+    MutatingCommand: {
+        required: ['command', 'idempotencyKey'],
+        optional: ['issuedAt', 'traceparent'],
+        refs: {},
+    },
+    Objective: {
+        required: ['goal'],
+        optional: ['acceptanceCriteria', 'instructions'],
+        refs: {},
+    },
+    OrchestrationError: {
+        required: ['code', 'message'],
+        optional: ['details', 'retryable', 'source'],
+        refs: {},
+    },
+    Permissions: {
+        required: [],
+        optional: ['agents', 'network', 'sandboxes', 'tools'],
+        refs: {},
+    },
+    Policy: {
+        required: [],
+        optional: [
+            'approvalRequired',
+            'budget',
+            'dataClassification',
+            'deadline',
+            'limits',
+            'permissions',
+        ],
+        refs: {
+            budget: 'Budget',
+            limits: 'DelegationLimits',
+            permissions: 'Permissions',
+        },
+    },
+    ProtocolEndpoint: {
+        required: ['protocol'],
+        optional: ['protocolVersion', 'transport', 'url'],
+        refs: {},
+    },
+    ReadCommand: {
+        required: ['command'],
+        optional: ['issuedAt', 'traceparent'],
+        refs: {},
+    },
+    Recovery: {
+        required: [],
+        optional: ['checkpointRequired', 'retryPolicy'],
+        refs: { retryPolicy: 'RetryPolicy' },
+    },
+    ReferenceResolution: {
+        required: ['status', 'uri'],
+        optional: [
+            'contentHash',
+            'error',
+            'mediaType',
+            'resolvedAt',
+            'resolvedVersion',
+            'sizeBytes',
+        ],
+        refs: { error: 'OrchestrationError' },
+    },
+    ReportAnswer: {
+        required: ['artifact', 'execution'],
+        optional: ['success'],
+        refs: { artifact: 'Artifact', execution: 'Execution' },
+    },
+    RetryPolicy: {
+        required: [],
+        optional: [
+            'backoffMultiplier',
+            'initialBackoffSeconds',
+            'maxBackoffSeconds',
+            'maxRetries',
+        ],
+        refs: {},
+    },
+    RuntimeRequirements: {
+        required: [],
+        optional: ['cpu', 'environment', 'gpu', 'memoryMb', 'region'],
+        refs: {},
+    },
+    Trace: { required: [], optional: ['traceparent', 'tracestate'], refs: {} },
+    TreeAnswer: {
+        required: ['tree'],
+        optional: ['success'],
+        refs: { tree: 'TreeSummary' },
+    },
+    TreeSummary: {
+        required: ['counts', 'executions', 'rootExecutionId', 'terminal'],
+        optional: [],
+        refs: { executions: 'ExecutionSummary' },
+    },
+    Usage: {
+        required: [],
+        optional: ['cost', 'currency', 'inputTokens', 'outputTokens'],
+        refs: {},
+    },
+    Worker: {
+        required: ['agentId', 'protocol'],
+        optional: ['endpoint', 'sessionId', 'supportedOperations', 'workflowUid'],
+        refs: {},
+    },
+    WorkerAnswer: {
+        required: ['worker'],
+        optional: ['detail', 'success'],
+        refs: { worker: 'Worker' },
+    },
+};
+export const ORCHESTRATION_API = [
+    {
+        operation: 'agents.attach',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/agents/attach',
+    },
+    {
+        operation: 'agents.create',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/agents/create',
+    },
+    {
+        operation: 'agents.discover',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/agents/discover',
+    },
+    {
+        operation: 'executions.list',
+        method: 'GET',
+        path: '/api/ai-agents/v1/orchestration/executions',
+    },
+    {
+        operation: 'executions.cancel',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/cancel',
+    },
+    {
+        operation: 'executions.checkpoint',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/checkpoint',
+    },
+    {
+        operation: 'executions.collect',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/collect',
+    },
+    {
+        operation: 'executions.delegate',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/delegate',
+    },
+    {
+        operation: 'executions.pause',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/pause',
+    },
+    {
+        operation: 'executions.resume',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/resume',
+    },
+    {
+        operation: 'executions.steer',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/steer',
+    },
+    {
+        operation: 'executions.terminate',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/terminate',
+    },
+    {
+        operation: 'executions.get',
+        method: 'GET',
+        path: '/api/ai-agents/v1/orchestration/executions/{execution_id}',
+    },
+    {
+        operation: 'executions.announce',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/{execution_id}/announce',
+    },
+    {
+        operation: 'executions.subscribe',
+        method: 'GET',
+        path: '/api/ai-agents/v1/orchestration/executions/{execution_id}/events',
+    },
+    {
+        operation: 'executions.report',
+        method: 'POST',
+        path: '/api/ai-agents/v1/orchestration/executions/{execution_id}/report',
+    },
+];