@arnilo/prism-supervisor 0.0.6 → 0.0.8

package/dist/a2a-types.d.ts

@@ -36,19 +36,51 @@ export interface A2AAgentCard {
     readonly security?: readonly Readonly<Record<string, readonly string[]>>[];
     readonly signatures?: readonly A2AAgentCardSignature[];
 }
-export interface A2ATextPart {
-    readonly text: string;
+interface A2APartBase {
+    readonly mediaType?: string;
+    readonly filename?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
+export type A2APart = (A2APartBase & {
+    readonly text: string;
+    readonly raw?: never;
+    readonly url?: never;
+    readonly data?: never;
+}) | (A2APartBase & {
+    readonly raw: string;
+    readonly text?: never;
+    readonly url?: never;
+    readonly data?: never;
+}) | (A2APartBase & {
+    readonly url: string;
+    readonly text?: never;
+    readonly raw?: never;
+    readonly data?: never;
+}) | (A2APartBase & {
+    readonly data: unknown;
+    readonly text?: never;
+    readonly raw?: never;
+    readonly url?: never;
+});
+export type A2ATextPart = Extract<A2APart, {
+    readonly text: string;
+}>;
 export interface A2AMessage {
     readonly role: "user" | "agent" | "ROLE_USER" | "ROLE_AGENT";
-    readonly parts: readonly A2ATextPart[];
+    readonly parts: readonly A2APart[];
     readonly messageId: string;
     readonly contextId?: string;
     readonly taskId?: string;
     readonly metadata?: Readonly<Record<string, unknown>>;
 }
-export type A2ATaskState = "TASK_STATE_SUBMITTED" | "TASK_STATE_WORKING" | "TASK_STATE_COMPLETED" | "TASK_STATE_FAILED" | "TASK_STATE_CANCELED";
+export interface A2AArtifact {
+    readonly artifactId: string;
+    readonly parts: readonly A2APart[];
+    readonly name?: string;
+    readonly description?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
+}
+export type A2ATaskState = "TASK_STATE_SUBMITTED" | "TASK_STATE_WORKING" | "TASK_STATE_COMPLETED" | "TASK_STATE_FAILED" | "TASK_STATE_CANCELED" | "TASK_STATE_INPUT_REQUIRED" | "TASK_STATE_REJECTED" | "TASK_STATE_AUTH_REQUIRED";
 export interface A2ATask {
     readonly id: string;
     readonly contextId: string;
@@ -57,16 +89,35 @@ export interface A2ATask {
         readonly timestamp: string;
         readonly message?: A2AMessage;
     };
-    readonly artifacts?: readonly {
-        readonly artifactId: string;
-        readonly parts: readonly A2ATextPart[];
-    }[];
+    readonly artifacts?: readonly A2AArtifact[];
+    readonly history?: readonly A2AMessage[];
+    readonly metadata?: Readonly<Record<string, unknown>>;
 }
+export type A2ATaskEvent = {
+    readonly eventId: string;
+    readonly task: A2ATask;
+} | {
+    readonly eventId: string;
+    readonly statusUpdate: {
+        readonly taskId: string;
+        readonly contextId: string;
+        readonly status: A2ATask["status"];
+    };
+} | {
+    readonly eventId: string;
+    readonly artifactUpdate: {
+        readonly taskId: string;
+        readonly contextId: string;
+        readonly artifact: A2AArtifact;
+        readonly append?: boolean;
+        readonly lastChunk?: boolean;
+    };
+};
 export type A2ARequestId = string | number | null;
 export interface A2AJsonRpcRequest {
     readonly jsonrpc: "2.0";
     readonly id: A2ARequestId;
-    readonly method: "SendMessage" | "SendStreamingMessage" | "GetExtendedAgentCard" | string;
+    readonly method: string;
     readonly params?: Readonly<Record<string, unknown>>;
 }
 export interface A2AJsonRpcResponse {
@@ -91,6 +142,88 @@ export type A2AAuthorizer = (input: {
 export interface A2AAgentExposure {
     readonly sessionFactory: (authorization: A2AAuthorization) => AgentSession | Promise<AgentSession>;
 }
+export interface A2ATaskPage {
+    readonly tasks: readonly A2ATask[];
+    readonly nextPageToken?: string;
+    readonly totalSize?: number;
+}
+export interface A2ATaskLifecycle {
+    start(input: {
+        readonly message: A2AMessage;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+        readonly returnImmediately?: boolean;
+    }): Promise<A2ATask>;
+    get(input: {
+        readonly id: string;
+        readonly historyLength: number;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2ATask | undefined>;
+    list(input: {
+        readonly pageSize: number;
+        readonly pageToken?: string;
+        readonly contextId?: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2ATaskPage>;
+    cancel(input: {
+        readonly id: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2ATask | undefined>;
+    subscribe(input: {
+        readonly id: string;
+        readonly afterEventId?: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): AsyncIterable<A2ATaskEvent>;
+}
+export interface A2APushConfig {
+    readonly id: string;
+    readonly taskId: string;
+    readonly url: string;
+    readonly token?: string;
+    readonly authentication?: {
+        readonly scheme: string;
+        readonly credentials?: string;
+    };
+}
+export interface A2APushProvider {
+    create(input: {
+        readonly config: A2APushConfig;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2APushConfig>;
+    get(input: {
+        readonly taskId: string;
+        readonly id: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<A2APushConfig | undefined>;
+    list(input: {
+        readonly taskId: string;
+        readonly pageSize: number;
+        readonly pageToken?: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<{
+        readonly configs: readonly A2APushConfig[];
+        readonly nextPageToken?: string;
+    }>;
+    delete(input: {
+        readonly taskId: string;
+        readonly id: string;
+        readonly authorization: A2AAuthorization;
+        readonly signal: AbortSignal;
+    }): Promise<boolean>;
+}
+export interface A2APartPolicy {
+    readonly allowRaw?: boolean;
+    readonly allowUrl?: boolean;
+    readonly allowData?: boolean;
+    readonly validateUrl?: (url: URL) => void | Promise<void>;
+}
 export interface A2ALimits {
     readonly maxRequestBytes?: number;
     readonly maxResponseBytes?: number;
@@ -100,11 +233,25 @@ export interface A2ALimits {
     readonly maxConcurrentRequests?: number;
     readonly timeoutMs?: number;
     readonly maxCardBytes?: number;
+    readonly maxIdBytes?: number;
+    readonly maxParts?: number;
+    readonly maxPartBytes?: number;
+    readonly maxRawBytes?: number;
+    readonly maxDataBytes?: number;
+    readonly maxArtifacts?: number;
+    readonly maxHistory?: number;
+    readonly maxPageSize?: number;
+    readonly maxCursorBytes?: number;
+    readonly maxReplayEvents?: number;
+    readonly maxPushConfigs?: number;
 }
 export interface CreateA2AHandlerOptions {
     readonly card: A2AAgentCard;
     readonly exposure: A2AAgentExposure;
     readonly authorize: A2AAuthorizer;
+    readonly tasks?: A2ATaskLifecycle;
+    readonly push?: A2APushProvider;
+    readonly parts?: A2APartPolicy;
     readonly endpointPath?: string;
     readonly redactor?: SecretRedactor;
     readonly limits?: A2ALimits;
@@ -121,6 +268,7 @@ export interface A2AClientOptions {
     readonly cardUrl?: string;
     readonly limits?: A2ALimits;
     readonly redactor?: SecretRedactor;
+    readonly parts?: A2APartPolicy;
 }
 export interface A2AClient {
     getCard(options?: {
@@ -129,7 +277,46 @@ export interface A2AClient {
     send(input: string, options?: {
         readonly signal?: AbortSignal;
     }): Promise<AgentRunResult>;
+    sendMessage(message: A2AMessage, options?: {
+        readonly signal?: AbortSignal;
+        readonly returnImmediately?: boolean;
+    }): Promise<A2ATask>;
     stream(input: string, options?: {
         readonly signal?: AbortSignal;
     }): AsyncIterable<string>;
+    getTask(id: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly historyLength?: number;
+    }): Promise<A2ATask>;
+    listTasks(options?: {
+        readonly signal?: AbortSignal;
+        readonly pageSize?: number;
+        readonly pageToken?: string;
+        readonly contextId?: string;
+    }): Promise<A2ATaskPage>;
+    cancelTask(id: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<A2ATask>;
+    subscribeToTask(id: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly afterEventId?: string;
+    }): AsyncIterable<A2ATaskEvent>;
+    createPushConfig(config: A2APushConfig, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<A2APushConfig>;
+    getPushConfig(taskId: string, id: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<A2APushConfig>;
+    listPushConfigs(taskId: string, options?: {
+        readonly signal?: AbortSignal;
+        readonly pageSize?: number;
+        readonly pageToken?: string;
+    }): Promise<{
+        readonly configs: readonly A2APushConfig[];
+        readonly nextPageToken?: string;
+    }>;
+    deletePushConfig(taskId: string, id: string, options?: {
+        readonly signal?: AbortSignal;
+    }): Promise<void>;
 }
+export {};

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 export * from "./a2a-card.js";
 export * from "./a2a-client.js";
+export * from "./a2a-parts.js";
+export * from "./a2a-push.js";
 export * from "./a2a-server.js";
 export type * from "./a2a-types.js";
 export * from "./errors.js";

package/dist/index.js

@@ -1,5 +1,7 @@
 export * from "./a2a-card.js";
 export * from "./a2a-client.js";
+export * from "./a2a-parts.js";
+export * from "./a2a-push.js";
 export * from "./a2a-server.js";
 export * from "./errors.js";
 export * from "./limits.js";

package/dist/supervisor.js

@@ -93,16 +93,32 @@ export function createSupervisor(options) {
                 redactor: options.redactor ?? childAgent.config.redactor,
             });
             const session = agent.createSession({ id: `${delegationId}-session`, metadata: { supervisorId: id, delegationId, resourceId, threadId } });
-            const result = await abortable(session.run(input, {
-                signal: controller.signal,
-                maxToolRounds: limits.maxSteps,
-                ownership: options.ownership,
-                redactor: options.redactor,
-                metadata: { ...request.metadata, supervisorId: id, delegationId, resourceId, threadId, depth },
-            }), controller.signal);
+            let result;
+            try {
+                result = await abortable(session.run(input, {
+                    signal: controller.signal,
+                    limits: {
+                        maxToolRounds: limits.maxSteps,
+                        maxToolCalls: limits.maxToolCalls,
+                        maxTotalTokens: limits.maxTokens,
+                        maxWallTimeMs: limits.timeoutMs,
+                    },
+                    ownership: options.ownership,
+                    redactor: options.redactor,
+                    metadata: { ...request.metadata, supervisorId: id, delegationId, resourceId, threadId, depth },
+                }), controller.signal);
+            }
+            catch (error) {
+                if (error instanceof AgentRunError && error.result.limit) {
+                    const label = error.result.limit.limit === "maxTotalTokens" ? "token"
+                        : error.result.limit.limit === "maxToolCalls" ? "tool-call"
+                            : error.result.limit.limit === "maxWallTimeMs" ? "timeout"
+                                : "run";
+                    throw new SupervisorLimitError(`Delegation ${label} limit exceeded`);
+                }
+                throw error;
+            }
             const totalTokens = result.usage?.totalTokens ?? ((result.usage?.inputTokens ?? 0) + (result.usage?.outputTokens ?? 0));
-            if (totalTokens > limits.maxTokens)
-                throw new SupervisorLimitError("Delegation token limit exceeded");
             events.publish({ type: "delegation_finished", childId: request.childId, delegationId, depth, status: result.status, totalTokens });
             await complete(toCompletion(result, request.childId, delegationId, depth, options));
             completionSent = true;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arnilo/prism-supervisor",
-  "version": "0.0.6",
-  "description": "Optional bounded local supervisor delegation and A2A 1.0 interoperability.",
+  "version": "0.0.8",
+  "description": "Bounded supervisor delegation and A2A 1.0 durable task, rich-part, reconnect, and push interoperability.",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -25,7 +25,7 @@
     "pack:dry-run": "npm pack --dry-run"
   },
   "peerDependencies": {
-    "@arnilo/prism": "0.0.6"
+    "@arnilo/prism": "0.0.8"
   },
   "devDependencies": {
     "@arnilo/prism": "file:../.."