@agen-ai/agent-protocol 0.1.0

package/dist/turns/types.d.ts

@@ -0,0 +1,207 @@
+import type { AgentError, AgentIsoDateTime, AgentItemId, AgentTurnId } from '../foundation/index.js';
+export interface AgentTextInputPart {
+    readonly type: 'text';
+    readonly text: string;
+}
+export declare const AGENT_IMAGE_INPUT_MEDIA_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
+export declare const AGENT_IMAGE_INPUT_SOURCE_KINDS: readonly ["url", "base64", "local_file"];
+export type AgentImageInputMediaType = (typeof AGENT_IMAGE_INPUT_MEDIA_TYPES)[number];
+export type AgentImageInputSourceKind = (typeof AGENT_IMAGE_INPUT_SOURCE_KINDS)[number];
+interface AgentImageInputSourceMetadata {
+    readonly mediaType: AgentImageInputMediaType;
+    readonly byteSize: number;
+    readonly widthPixels: number;
+    readonly heightPixels: number;
+}
+export type AgentImageInputSource = Readonly<AgentImageInputSourceMetadata & {
+    type: 'url';
+    url: string;
+}> | Readonly<AgentImageInputSourceMetadata & {
+    type: 'base64';
+    data: string;
+}> | Readonly<AgentImageInputSourceMetadata & {
+    type: 'local_file';
+    path: string;
+    sha256: string;
+}>;
+export interface AgentImageInputPart {
+    readonly type: 'image';
+    readonly source: AgentImageInputSource;
+}
+export type AgentTurnInputPart = AgentTextInputPart | AgentImageInputPart;
+export declare const AGENT_TURN_INTERACTION_MODES: readonly ["default", "plan"];
+export type AgentTurnInteractionMode = (typeof AGENT_TURN_INTERACTION_MODES)[number];
+export interface AgentTurnInputContent {
+    readonly parts: readonly AgentTurnInputPart[];
+    readonly summary?: string;
+}
+export interface AgentTurnRunInput extends AgentTurnInputContent {
+    readonly turnId: AgentTurnId;
+    readonly interactionMode: AgentTurnInteractionMode;
+    readonly deadlineAt?: AgentIsoDateTime;
+}
+export type AgentTurnInterruptionReason = 'user_requested' | 'timeout' | 'shutdown' | 'superseded' | 'other';
+export interface AgentTurnInterruptionInput {
+    readonly turnId: AgentTurnId;
+    readonly reason: AgentTurnInterruptionReason;
+    readonly requestedAt?: AgentIsoDateTime;
+}
+export declare const AGENT_ITEM_KINDS: readonly ["user_message", "assistant_message", "reasoning", "plan", "command_execution", "file_change", "mcp_tool_call", "dynamic_tool_call", "collaboration_tool_call", "web_search", "browser_action", "computer_action", "image_view", "review", "context_compaction", "unknown"];
+export type AgentItemKind = (typeof AGENT_ITEM_KINDS)[number];
+export declare const AGENT_ITEM_STATUSES: readonly ["pending", "in_progress", "completed", "failed", "canceled", "unknown"];
+export type AgentItemStatus = (typeof AGENT_ITEM_STATUSES)[number];
+export declare const AGENT_CONTENT_STREAM_KINDS: readonly ["assistant_text", "reasoning_text", "reasoning_summary", "plan_text", "command_output", "file_change_output", "unknown"];
+export type AgentContentStreamKind = (typeof AGENT_CONTENT_STREAM_KINDS)[number];
+export type AgentTurnState = 'running' | 'waiting_for_request';
+export type AgentTurnOutcome = 'completed' | 'failed' | 'canceled' | 'expired';
+export interface AgentItemSnapshotBase {
+    readonly itemId: AgentItemId;
+    readonly status: AgentItemStatus;
+    readonly title?: string;
+    readonly summary?: string;
+}
+export interface AgentUserMessageItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'user_message';
+}
+export interface AgentAssistantMessageItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'assistant_message';
+}
+export interface AgentReasoningItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'reasoning';
+}
+export interface AgentPlanItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'plan';
+}
+export interface AgentContextCompactionItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'context_compaction';
+}
+export interface AgentUnknownItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'unknown';
+}
+export interface AgentCommandExecutionDetails {
+    readonly commandSummary?: string;
+    readonly workingPath?: string;
+    readonly exitCode?: number;
+    readonly durationMs?: number;
+    readonly truncated?: true;
+}
+export interface AgentCommandExecutionItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'command_execution';
+    readonly details?: AgentCommandExecutionDetails;
+}
+export declare const AGENT_FILE_CHANGE_KINDS: readonly ["created", "modified", "deleted", "renamed", "unknown"];
+export type AgentFileChangeKind = (typeof AGENT_FILE_CHANGE_KINDS)[number];
+export interface AgentFileChange {
+    readonly path: string;
+    readonly changeKind: AgentFileChangeKind;
+}
+export interface AgentFileChangeDetails {
+    readonly changes: readonly AgentFileChange[];
+    readonly truncated?: true;
+}
+export interface AgentFileChangeItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'file_change';
+    readonly details?: AgentFileChangeDetails;
+}
+export interface AgentMcpToolCallDetails {
+    readonly serverName?: string;
+    readonly toolName?: string;
+    readonly actionSummary?: string;
+    readonly durationMs?: number;
+    readonly truncated?: true;
+}
+export interface AgentMcpToolCallItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'mcp_tool_call';
+    readonly details?: AgentMcpToolCallDetails;
+}
+export interface AgentDynamicToolCallDetails {
+    readonly toolName?: string;
+    readonly actionSummary?: string;
+    readonly durationMs?: number;
+    readonly success?: boolean;
+    readonly truncated?: true;
+}
+export interface AgentDynamicToolCallItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'dynamic_tool_call';
+    readonly details?: AgentDynamicToolCallDetails;
+}
+export interface AgentCollaborationToolCallDetails {
+    readonly toolName?: string;
+    readonly actionSummary?: string;
+    readonly truncated?: true;
+}
+export interface AgentCollaborationToolCallItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'collaboration_tool_call';
+    readonly details?: AgentCollaborationToolCallDetails;
+}
+export interface AgentWebSearchDetails {
+    readonly querySummary?: string;
+    readonly actionSummary?: string;
+    readonly truncated?: true;
+}
+export interface AgentWebSearchItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'web_search';
+    readonly details?: AgentWebSearchDetails;
+}
+export interface AgentBrowserActionDetails {
+    readonly actionSummary: string;
+    readonly truncated?: true;
+}
+export interface AgentBrowserActionItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'browser_action';
+    readonly details?: AgentBrowserActionDetails;
+}
+export interface AgentComputerActionDetails {
+    readonly actionSummary: string;
+    readonly truncated?: true;
+}
+export interface AgentComputerActionItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'computer_action';
+    readonly details?: AgentComputerActionDetails;
+}
+export interface AgentImageViewDetails {
+    readonly filePath?: string;
+    readonly actionSummary?: string;
+    readonly truncated?: true;
+}
+export interface AgentImageViewItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'image_view';
+    readonly details?: AgentImageViewDetails;
+}
+export type AgentReviewDetails = Readonly<{
+    phase: 'entered';
+    target: string;
+    truncated?: true;
+}> | Readonly<{
+    phase: 'exited';
+    report: string;
+    truncated?: true;
+}>;
+export interface AgentReviewItemSnapshot extends AgentItemSnapshotBase {
+    readonly itemKind: 'review';
+    readonly details: AgentReviewDetails;
+}
+export type AgentItemSnapshot = AgentUserMessageItemSnapshot | AgentAssistantMessageItemSnapshot | AgentReasoningItemSnapshot | AgentPlanItemSnapshot | AgentCommandExecutionItemSnapshot | AgentFileChangeItemSnapshot | AgentMcpToolCallItemSnapshot | AgentDynamicToolCallItemSnapshot | AgentCollaborationToolCallItemSnapshot | AgentWebSearchItemSnapshot | AgentBrowserActionItemSnapshot | AgentComputerActionItemSnapshot | AgentImageViewItemSnapshot | AgentReviewItemSnapshot | AgentContextCompactionItemSnapshot | AgentUnknownItemSnapshot;
+export interface AgentPlanStep {
+    readonly stepId: string;
+    readonly text: string;
+    readonly status: 'pending' | 'in_progress' | 'completed' | 'canceled';
+    readonly priority?: 'low' | 'medium' | 'high';
+}
+export interface AgentDiffSummary {
+    readonly summary: string;
+    readonly fileCount: number;
+    readonly byteSize: number;
+    readonly additions?: number;
+    readonly deletions?: number;
+    readonly binary?: boolean;
+    readonly malformed?: boolean;
+    readonly truncated?: boolean;
+}
+export interface AgentTurnCompletedPayload {
+    readonly outcome: AgentTurnOutcome;
+    readonly reason?: string;
+    readonly error?: AgentError;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/turns/types.js

@@ -0,0 +1,62 @@
+const AGENT_IMAGE_INPUT_MEDIA_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/webp"
+];
+const AGENT_IMAGE_INPUT_SOURCE_KINDS = [
+  "url",
+  "base64",
+  "local_file"
+];
+const AGENT_TURN_INTERACTION_MODES = ["default", "plan"];
+const AGENT_ITEM_KINDS = [
+  "user_message",
+  "assistant_message",
+  "reasoning",
+  "plan",
+  "command_execution",
+  "file_change",
+  "mcp_tool_call",
+  "dynamic_tool_call",
+  "collaboration_tool_call",
+  "web_search",
+  "browser_action",
+  "computer_action",
+  "image_view",
+  "review",
+  "context_compaction",
+  "unknown"
+];
+const AGENT_ITEM_STATUSES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "failed",
+  "canceled",
+  "unknown"
+];
+const AGENT_CONTENT_STREAM_KINDS = [
+  "assistant_text",
+  "reasoning_text",
+  "reasoning_summary",
+  "plan_text",
+  "command_output",
+  "file_change_output",
+  "unknown"
+];
+const AGENT_FILE_CHANGE_KINDS = [
+  "created",
+  "modified",
+  "deleted",
+  "renamed",
+  "unknown"
+];
+export {
+  AGENT_CONTENT_STREAM_KINDS,
+  AGENT_FILE_CHANGE_KINDS,
+  AGENT_IMAGE_INPUT_MEDIA_TYPES,
+  AGENT_IMAGE_INPUT_SOURCE_KINDS,
+  AGENT_ITEM_KINDS,
+  AGENT_ITEM_STATUSES,
+  AGENT_TURN_INTERACTION_MODES
+};

package/dist/zod/artifacts.d.ts

@@ -0,0 +1,4 @@
+import { z } from 'zod/v4';
+import { type AgentArtifactDescriptor } from '../artifacts/types.js';
+export declare const AgentArtifactDescriptorSchema: z.ZodType<AgentArtifactDescriptor>;
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/zod/artifacts.js

@@ -0,0 +1,28 @@
+import { z } from "zod/v4";
+import {
+  AGENT_ARTIFACT_BYTE_SIZE_MAX,
+  AGENT_ARTIFACT_DISPLAY_NAME_MAX_LENGTH,
+  AGENT_ARTIFACT_KINDS
+} from "../artifacts/types.js";
+import { AGENT_PROTOCOL_SUMMARY_MAX_LENGTH } from "../foundation/types.js";
+import {
+  AgentArtifactIdSchema,
+  createAgentCanonicalNonBlankStringSchema
+} from "./foundation.js";
+const AgentArtifactDescriptorSchema = z.object({
+  artifactId: AgentArtifactIdSchema,
+  kind: z.enum(AGENT_ARTIFACT_KINDS),
+  displayName: createAgentCanonicalNonBlankStringSchema(
+    AGENT_ARTIFACT_DISPLAY_NAME_MAX_LENGTH
+  ),
+  mediaType: z.string().min(1).max(160).regex(/^[a-z0-9!#$&^_.+-]+\/[a-z0-9!#$&^_.+-]+(?:;[ -~]+)?$/iu).optional(),
+  byteSize: z.number().int().min(0).max(AGENT_ARTIFACT_BYTE_SIZE_MAX).optional(),
+  digest: z.object({
+    algorithm: z.literal("sha256"),
+    value: z.string().regex(/^[a-f0-9]{64}$/u)
+  }).strict().readonly().optional(),
+  summary: z.string().max(AGENT_PROTOCOL_SUMMARY_MAX_LENGTH).optional()
+}).strict().readonly();
+export {
+  AgentArtifactDescriptorSchema
+};

package/dist/zod/capabilities.d.ts

@@ -0,0 +1,180 @@
+import { z } from 'zod/v4';
+import { type AgentCapabilities } from '../capabilities/types.js';
+export declare const AgentImageInputCapabilitySchema: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"unsupported">;
+}, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+    kind: z.ZodLiteral<"supported">;
+    sourceKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        url: "url";
+        base64: "base64";
+        local_file: "local_file";
+    }>>>;
+    mediaTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+        "image/png": "image/png";
+        "image/jpeg": "image/jpeg";
+        "image/webp": "image/webp";
+    }>>>;
+    maxImages: z.ZodNumber;
+    maxBytesPerImage: z.ZodNumber;
+    maxTotalBytes: z.ZodNumber;
+    maxWidthPixels: z.ZodNumber;
+    maxHeightPixels: z.ZodNumber;
+    maxPixelsPerImage: z.ZodNumber;
+    supportsImageOnly: z.ZodBoolean;
+}, z.core.$strict>>], "kind">;
+export declare const AgentOperationInputCapabilitySchema: z.ZodReadonly<z.ZodObject<{
+    text: z.ZodLiteral<true>;
+    images: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        sourceKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            url: "url";
+            base64: "base64";
+            local_file: "local_file";
+        }>>>;
+        mediaTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            "image/png": "image/png";
+            "image/jpeg": "image/jpeg";
+            "image/webp": "image/webp";
+        }>>>;
+        maxImages: z.ZodNumber;
+        maxBytesPerImage: z.ZodNumber;
+        maxTotalBytes: z.ZodNumber;
+        maxWidthPixels: z.ZodNumber;
+        maxHeightPixels: z.ZodNumber;
+        maxPixelsPerImage: z.ZodNumber;
+        supportsImageOnly: z.ZodBoolean;
+    }, z.core.$strict>>], "kind">;
+}, z.core.$strict>>;
+export declare const AgentCapabilitiesPortableSchema: z.ZodReadonly<z.ZodObject<{
+    protocolVersion: z.ZodLiteral<6>;
+    providerKey: z.ZodType<import("../index.js").AgentProviderKey, unknown, z.core.$ZodTypeInternals<import("../index.js").AgentProviderKey, unknown>>;
+    sessions: z.ZodReadonly<z.ZodObject<{
+        create: z.ZodLiteral<true>;
+        resume: z.ZodBoolean;
+        branch: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"through_turn">;
+        }, z.core.$strict>>], "kind">;
+    }, z.core.$strict>>;
+    turns: z.ZodReadonly<z.ZodObject<{
+        interactionModes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            default: "default";
+            plan: "plan";
+        }>>>;
+        interrupt: z.ZodBoolean;
+        steer: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"supported">;
+            input: z.ZodReadonly<z.ZodObject<{
+                text: z.ZodLiteral<true>;
+                images: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodLiteral<"unsupported">;
+                }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+                    kind: z.ZodLiteral<"supported">;
+                    sourceKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                        url: "url";
+                        base64: "base64";
+                        local_file: "local_file";
+                    }>>>;
+                    mediaTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                        "image/png": "image/png";
+                        "image/jpeg": "image/jpeg";
+                        "image/webp": "image/webp";
+                    }>>>;
+                    maxImages: z.ZodNumber;
+                    maxBytesPerImage: z.ZodNumber;
+                    maxTotalBytes: z.ZodNumber;
+                    maxWidthPixels: z.ZodNumber;
+                    maxHeightPixels: z.ZodNumber;
+                    maxPixelsPerImage: z.ZodNumber;
+                    supportsImageOnly: z.ZodBoolean;
+                }, z.core.$strict>>], "kind">;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>], "kind">;
+    }, z.core.$strict>>;
+    requests: z.ZodReadonly<z.ZodObject<{
+        approval: z.ZodBoolean;
+        elicitation: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"text">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"structured">;
+        }, z.core.$strict>>], "kind">;
+    }, z.core.$strict>>;
+    input: z.ZodReadonly<z.ZodObject<{
+        text: z.ZodLiteral<true>;
+        images: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"unsupported">;
+        }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+            kind: z.ZodLiteral<"supported">;
+            sourceKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                url: "url";
+                base64: "base64";
+                local_file: "local_file";
+            }>>>;
+            mediaTypes: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+                "image/png": "image/png";
+                "image/jpeg": "image/jpeg";
+                "image/webp": "image/webp";
+            }>>>;
+            maxImages: z.ZodNumber;
+            maxBytesPerImage: z.ZodNumber;
+            maxTotalBytes: z.ZodNumber;
+            maxWidthPixels: z.ZodNumber;
+            maxHeightPixels: z.ZodNumber;
+            maxPixelsPerImage: z.ZodNumber;
+            supportsImageOnly: z.ZodBoolean;
+        }, z.core.$strict>>], "kind">;
+    }, z.core.$strict>>;
+    output: z.ZodReadonly<z.ZodObject<{
+        streaming: z.ZodBoolean;
+        plans: z.ZodBoolean;
+        fileChanges: z.ZodEnum<{
+            structured: "structured";
+            none: "none";
+            final_diff: "final_diff";
+        }>;
+        artifactKinds: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            file: "file";
+            image: "image";
+            plan: "plan";
+            other: "other";
+            report: "report";
+            diff: "diff";
+            log: "log";
+        }>>>;
+    }, z.core.$strict>>;
+    configuration: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"managed">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"selectable">;
+        fields: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
+            key: z.ZodString;
+            optionIds: z.ZodReadonly<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>], "kind">;
+    interactionExtensions: z.ZodReadonly<z.ZodObject<{
+        slashCommands: z.ZodBoolean;
+        mcp: z.ZodBoolean;
+        subagents: z.ZodBoolean;
+        imageGeneration: z.ZodBoolean;
+    }, z.core.$strict>>;
+    authentication: z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"unsupported">;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        kind: z.ZodLiteral<"supported">;
+        flows: z.ZodReadonly<z.ZodArray<z.ZodEnum<{
+            device_code: "device_code";
+            browser: "browser";
+            terminal: "terminal";
+        }>>>;
+    }, z.core.$strict>>], "kind">;
+    versionReporting: z.ZodBoolean;
+}, z.core.$strict>>;
+export declare const AgentCapabilitiesSchema: z.ZodType<AgentCapabilities>;
+//# sourceMappingURL=capabilities.d.ts.map