@agen-ai/agent-protocol 0.1.0

package/dist/jsonSchema/index.d.ts

@@ -0,0 +1,2 @@
+export * from './generated.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/jsonSchema/index.js

@@ -0,0 +1 @@
+export * from "./generated.js";

package/dist/public/artifacts.d.ts

@@ -0,0 +1,2 @@
+export * from '../artifacts/index.js';
+//# sourceMappingURL=artifacts.d.ts.map

package/dist/public/artifacts.js

@@ -0,0 +1 @@
+export * from "../artifacts/index.js";

package/dist/public/capabilities.d.ts

@@ -0,0 +1,2 @@
+export * from '../capabilities/index.js';
+//# sourceMappingURL=capabilities.d.ts.map

package/dist/public/capabilities.js

@@ -0,0 +1 @@
+export * from "../capabilities/index.js";

package/dist/public/events.d.ts

@@ -0,0 +1,2 @@
+export * from '../events/index.js';
+//# sourceMappingURL=events.d.ts.map

package/dist/public/events.js

@@ -0,0 +1 @@
+export * from "../events/index.js";

package/dist/public/index.d.ts

@@ -0,0 +1,8 @@
+export * from '../foundation/index.js';
+export * from '../sessions/index.js';
+export * from '../turns/index.js';
+export * from '../requests/index.js';
+export * from '../capabilities/index.js';
+export * from '../artifacts/index.js';
+export * from '../events/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/public/index.js

@@ -0,0 +1,7 @@
+export * from "../foundation/index.js";
+export * from "../sessions/index.js";
+export * from "../turns/index.js";
+export * from "../requests/index.js";
+export * from "../capabilities/index.js";
+export * from "../artifacts/index.js";
+export * from "../events/index.js";

package/dist/public/requests.d.ts

@@ -0,0 +1,2 @@
+export * from '../requests/index.js';
+//# sourceMappingURL=requests.d.ts.map

package/dist/public/requests.js

@@ -0,0 +1 @@
+export * from "../requests/index.js";

package/dist/public/sessions.d.ts

@@ -0,0 +1,2 @@
+export * from '../sessions/index.js';
+//# sourceMappingURL=sessions.d.ts.map

package/dist/public/sessions.js

@@ -0,0 +1 @@
+export * from "../sessions/index.js";

package/dist/public/turns.d.ts

@@ -0,0 +1,2 @@
+export * from '../turns/index.js';
+//# sourceMappingURL=turns.d.ts.map

package/dist/public/turns.js

@@ -0,0 +1 @@
+export * from "../turns/index.js";

package/dist/requests/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './parsers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/requests/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/requests/parsers.d.ts

@@ -0,0 +1,9 @@
+import { type AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentRequest, AgentRequestResolution } from './types.js';
+export declare function parseAgentRequest(input: unknown): AgentRequest;
+export declare function safeParseAgentRequest(input: unknown): AgentProtocolParseResult<AgentRequest>;
+export declare function parseAgentRequestResolution(input: unknown): AgentRequestResolution;
+export declare function safeParseAgentRequestResolution(input: unknown): AgentProtocolParseResult<AgentRequestResolution>;
+export declare function safeParseAgentRequestResolutionFor(requestInput: unknown, resolutionInput: unknown): AgentProtocolParseResult<AgentRequestResolution>;
+export declare function parseAgentRequestResolutionFor(requestInput: unknown, resolutionInput: unknown): AgentRequestResolution;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/requests/parsers.js

@@ -0,0 +1,134 @@
+import {
+  AgentProtocolValidationError
+} from "../foundation/index.js";
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentRequestResolutionSchema,
+  AgentRequestSchema
+} from "../zod/requests.js";
+function parseAgentRequest(input) {
+  return parseWithSchema(AgentRequestSchema, input);
+}
+function safeParseAgentRequest(input) {
+  return safeParseWithSchema(AgentRequestSchema, input);
+}
+function parseAgentRequestResolution(input) {
+  return parseWithSchema(AgentRequestResolutionSchema, input);
+}
+function safeParseAgentRequestResolution(input) {
+  return safeParseWithSchema(AgentRequestResolutionSchema, input);
+}
+function issue(path, message) {
+  return { code: "custom", path, message };
+}
+function fieldMap(request) {
+  return new Map(request.fields.map((field) => [field.fieldId, field]));
+}
+function choiceAnswerIssues(field, answer, answerIndex) {
+  const issues = [];
+  const allowedValues = new Set(field.options.map((option) => option.value));
+  if (answer.values.some((value) => !allowedValues.has(value))) {
+    issues.push(issue(
+      ["answers", answerIndex, "values"],
+      "Choice answers must reference options declared by the request."
+    ));
+  }
+  const selectionCount = answer.values.length + (answer.other === void 0 ? 0 : 1);
+  if (!field.multiple && selectionCount > 1) {
+    issues.push(issue(
+      ["answers", answerIndex],
+      "This request field accepts only one choice."
+    ));
+  }
+  if (answer.other !== void 0 && !field.allowOther) {
+    issues.push(issue(
+      ["answers", answerIndex, "other"],
+      "This request field does not accept a custom choice."
+    ));
+  }
+  if (answer.values.length === 0 && answer.other === void 0) {
+    issues.push(issue(
+      ["answers", answerIndex],
+      "A choice answer requires a declared option or a custom choice."
+    ));
+  }
+  return issues;
+}
+function answerIssues(field, answer, answerIndex) {
+  if (field.kind !== answer.kind) {
+    return [issue(
+      ["answers", answerIndex, "kind"],
+      "Answer kind must match the corresponding request field."
+    )];
+  }
+  return field.kind === "choice" && answer.kind === "choice" ? choiceAnswerIssues(field, answer, answerIndex) : [];
+}
+function resolutionIssues(request, resolution) {
+  const issues = [];
+  if (request.requestKind !== resolution.requestKind) {
+    issues.push(issue(
+      ["requestKind"],
+      "Resolution kind must match the request kind."
+    ));
+  }
+  if (request.requestId !== resolution.requestId) {
+    issues.push(issue(
+      ["requestId"],
+      "Resolution requestId must match the opened request."
+    ));
+  }
+  if (request.requestKind !== "elicitation" || resolution.requestKind !== "elicitation" || resolution.disposition !== "answered") {
+    return issues;
+  }
+  const fields = fieldMap(request);
+  const answered = /* @__PURE__ */ new Set();
+  resolution.answers.forEach((answer, answerIndex) => {
+    if (answered.has(answer.fieldId)) {
+      issues.push(issue(
+        ["answers", answerIndex, "fieldId"],
+        "Each request field may be answered once."
+      ));
+      return;
+    }
+    answered.add(answer.fieldId);
+    const field = fields.get(answer.fieldId);
+    if (!field) {
+      issues.push(issue(
+        ["answers", answerIndex, "fieldId"],
+        "Answer fieldId must reference a field declared by the request."
+      ));
+      return;
+    }
+    issues.push(...answerIssues(field, answer, answerIndex));
+  });
+  for (const field of request.fields) {
+    if (field.required && !answered.has(field.fieldId)) {
+      issues.push(issue(
+        ["answers"],
+        `Required request field ${field.fieldId} is missing an answer.`
+      ));
+    }
+  }
+  return issues;
+}
+function safeParseAgentRequestResolutionFor(requestInput, resolutionInput) {
+  const request = safeParseAgentRequest(requestInput);
+  if (!request.success) return request;
+  const resolution = safeParseAgentRequestResolution(resolutionInput);
+  if (!resolution.success) return resolution;
+  const issues = resolutionIssues(request.data, resolution.data);
+  return issues.length === 0 ? resolution : { success: false, issues };
+}
+function parseAgentRequestResolutionFor(requestInput, resolutionInput) {
+  const parsed = safeParseAgentRequestResolutionFor(requestInput, resolutionInput);
+  if (parsed.success) return parsed.data;
+  throw new AgentProtocolValidationError(parsed.issues);
+}
+export {
+  parseAgentRequest,
+  parseAgentRequestResolution,
+  parseAgentRequestResolutionFor,
+  safeParseAgentRequest,
+  safeParseAgentRequestResolution,
+  safeParseAgentRequestResolutionFor
+};

package/dist/requests/types.d.ts

@@ -0,0 +1,89 @@
+import type { AgentArtifactId, AgentIsoDateTime, AgentRequestFieldId, AgentRequestId } from '../foundation/index.js';
+interface AgentApprovalSubjectBase {
+    readonly title: string;
+    readonly description?: string;
+}
+export type AgentApprovalSubject = (AgentApprovalSubjectBase & Readonly<{
+    kind: 'plan';
+    artifactId: AgentArtifactId;
+}>) | (AgentApprovalSubjectBase & Readonly<{
+    kind: 'command' | 'file_change' | 'tool' | 'other';
+    artifactId?: never;
+}>);
+export interface AgentApprovalRequest {
+    readonly requestKind: 'approval';
+    readonly requestId: AgentRequestId;
+    readonly prompt: string;
+    readonly subject: AgentApprovalSubject;
+    readonly expiresAt?: AgentIsoDateTime;
+}
+export interface AgentRequestChoice {
+    readonly value: string;
+    readonly label: string;
+    readonly description?: string;
+}
+interface AgentElicitationFieldBase {
+    readonly fieldId: AgentRequestFieldId;
+    readonly label: string;
+    readonly description?: string;
+    readonly required: boolean;
+}
+export interface AgentTextElicitationField extends AgentElicitationFieldBase {
+    readonly kind: 'text';
+    readonly multiline?: boolean;
+}
+export interface AgentChoiceElicitationField extends AgentElicitationFieldBase {
+    readonly kind: 'choice';
+    readonly options: readonly AgentRequestChoice[];
+    readonly multiple: boolean;
+    readonly allowOther: boolean;
+}
+export interface AgentBooleanElicitationField extends AgentElicitationFieldBase {
+    readonly kind: 'boolean';
+}
+export type AgentElicitationField = AgentTextElicitationField | AgentChoiceElicitationField | AgentBooleanElicitationField;
+export interface AgentElicitationRequest {
+    readonly requestKind: 'elicitation';
+    readonly requestId: AgentRequestId;
+    readonly prompt: string;
+    readonly fields: readonly AgentElicitationField[];
+    readonly expiresAt?: AgentIsoDateTime;
+}
+export type AgentRequest = AgentApprovalRequest | AgentElicitationRequest;
+export interface AgentApprovalResolution {
+    readonly requestKind: 'approval';
+    readonly requestId: AgentRequestId;
+    readonly decision: 'approved' | 'denied' | 'canceled';
+}
+export interface AgentTextElicitationAnswer {
+    readonly fieldId: AgentRequestFieldId;
+    readonly kind: 'text';
+    readonly value: string;
+}
+export interface AgentChoiceElicitationAnswer {
+    readonly fieldId: AgentRequestFieldId;
+    readonly kind: 'choice';
+    readonly values: readonly string[];
+    readonly other?: string;
+}
+export interface AgentBooleanElicitationAnswer {
+    readonly fieldId: AgentRequestFieldId;
+    readonly kind: 'boolean';
+    readonly value: boolean;
+}
+export type AgentElicitationAnswer = AgentTextElicitationAnswer | AgentChoiceElicitationAnswer | AgentBooleanElicitationAnswer;
+export interface AgentAnsweredElicitationResolution {
+    readonly requestKind: 'elicitation';
+    readonly requestId: AgentRequestId;
+    readonly disposition: 'answered';
+    readonly answers: readonly AgentElicitationAnswer[];
+}
+export interface AgentCanceledElicitationResolution {
+    readonly requestKind: 'elicitation';
+    readonly requestId: AgentRequestId;
+    readonly disposition: 'canceled';
+}
+export type AgentElicitationResolution = AgentAnsweredElicitationResolution | AgentCanceledElicitationResolution;
+export type AgentRequestResolution = AgentApprovalResolution | AgentElicitationResolution;
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/sessions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './parsers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/sessions/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/sessions/parsers.d.ts

@@ -0,0 +1,10 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentSessionBinding, AgentSessionConfiguration, AgentSessionOpenInput } from './types.js';
+export declare function parseAgentSessionBinding(input: unknown): AgentSessionBinding;
+export declare function safeParseAgentSessionBinding(input: unknown): AgentProtocolParseResult<AgentSessionBinding>;
+export declare function parseAgentSessionConfiguration(input: unknown): AgentSessionConfiguration;
+export declare function safeParseAgentSessionConfiguration(input: unknown): AgentProtocolParseResult<AgentSessionConfiguration>;
+export declare function parseAgentSessionOpenInput(input: unknown): AgentSessionOpenInput;
+export declare function safeParseAgentSessionOpenInput(input: unknown): AgentProtocolParseResult<AgentSessionOpenInput>;
+export declare function matchesAgentSessionBinding(actual: unknown, expected: unknown): boolean;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/sessions/parsers.js

@@ -0,0 +1,38 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentSessionBindingSchema,
+  AgentSessionConfigurationSchema,
+  AgentSessionOpenInputSchema
+} from "../zod/sessions.js";
+function parseAgentSessionBinding(input) {
+  return parseWithSchema(AgentSessionBindingSchema, input);
+}
+function safeParseAgentSessionBinding(input) {
+  return safeParseWithSchema(AgentSessionBindingSchema, input);
+}
+function parseAgentSessionConfiguration(input) {
+  return parseWithSchema(AgentSessionConfigurationSchema, input);
+}
+function safeParseAgentSessionConfiguration(input) {
+  return safeParseWithSchema(AgentSessionConfigurationSchema, input);
+}
+function parseAgentSessionOpenInput(input) {
+  return parseWithSchema(AgentSessionOpenInputSchema, input);
+}
+function safeParseAgentSessionOpenInput(input) {
+  return safeParseWithSchema(AgentSessionOpenInputSchema, input);
+}
+function matchesAgentSessionBinding(actual, expected) {
+  const parsedActual = safeParseAgentSessionBinding(actual);
+  const parsedExpected = safeParseAgentSessionBinding(expected);
+  return parsedActual.success && parsedExpected.success && parsedActual.data.conversationId === parsedExpected.data.conversationId && parsedActual.data.historyAnchor === parsedExpected.data.historyAnchor;
+}
+export {
+  matchesAgentSessionBinding,
+  parseAgentSessionBinding,
+  parseAgentSessionConfiguration,
+  parseAgentSessionOpenInput,
+  safeParseAgentSessionBinding,
+  safeParseAgentSessionConfiguration,
+  safeParseAgentSessionOpenInput
+};

package/dist/sessions/types.d.ts

@@ -0,0 +1,37 @@
+import type { AgentConfigurationRevisionId, AgentJsonValue, AgentProviderConversationId, AgentProviderHistoryAnchor, AgentSessionId, AgentTurnId } from '../foundation/index.js';
+export interface AgentSessionBinding {
+    readonly conversationId: AgentProviderConversationId;
+    readonly historyAnchor?: AgentProviderHistoryAnchor;
+}
+export interface AgentSessionConfiguration {
+    readonly revision: AgentConfigurationRevisionId;
+    readonly values: Readonly<Record<string, AgentJsonValue>>;
+}
+export interface AgentSessionCreateInput {
+    readonly operation: 'create';
+    readonly sessionId: AgentSessionId;
+    readonly configuration: AgentSessionConfiguration;
+}
+export interface AgentSessionResumeInput {
+    readonly operation: 'resume';
+    readonly sessionId: AgentSessionId;
+    readonly binding: AgentSessionBinding;
+    readonly configuration: AgentSessionConfiguration;
+}
+export interface AgentSessionBranchSource {
+    readonly sessionId: AgentSessionId;
+    readonly binding: AgentSessionBinding;
+    readonly throughTurn: Readonly<{
+        turnId: AgentTurnId;
+        historyAnchor: AgentProviderHistoryAnchor;
+    }>;
+}
+export interface AgentSessionBranchInput {
+    readonly operation: 'branch';
+    readonly sessionId: AgentSessionId;
+    readonly source: AgentSessionBranchSource;
+    readonly configuration: AgentSessionConfiguration;
+}
+export type AgentSessionOpenInput = AgentSessionCreateInput | AgentSessionResumeInput | AgentSessionBranchInput;
+export type AgentSessionOpenDisposition = 'created' | 'resumed' | 'branched';
+//# sourceMappingURL=types.d.ts.map

package/dist/turns/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './parsers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/turns/index.js

@@ -0,0 +1,2 @@
+export * from "./types.js";
+export * from "./parsers.js";

package/dist/turns/parsers.d.ts

@@ -0,0 +1,11 @@
+import type { AgentProtocolParseResult } from '../foundation/index.js';
+import type { AgentItemSnapshot, AgentTurnInputContent, AgentTurnInterruptionInput, AgentTurnRunInput } from './types.js';
+export declare function parseAgentTurnInputContent(input: unknown): AgentTurnInputContent;
+export declare function safeParseAgentTurnInputContent(input: unknown): AgentProtocolParseResult<AgentTurnInputContent>;
+export declare function parseAgentTurnRunInput(input: unknown): AgentTurnRunInput;
+export declare function safeParseAgentTurnRunInput(input: unknown): AgentProtocolParseResult<AgentTurnRunInput>;
+export declare function parseAgentTurnInterruptionInput(input: unknown): AgentTurnInterruptionInput;
+export declare function safeParseAgentTurnInterruptionInput(input: unknown): AgentProtocolParseResult<AgentTurnInterruptionInput>;
+export declare function parseAgentItemSnapshot(input: unknown): AgentItemSnapshot;
+export declare function safeParseAgentItemSnapshot(input: unknown): AgentProtocolParseResult<AgentItemSnapshot>;
+//# sourceMappingURL=parsers.d.ts.map

package/dist/turns/parsers.js

@@ -0,0 +1,41 @@
+import { parseWithSchema, safeParseWithSchema } from "../internal/parsers.js";
+import {
+  AgentItemSnapshotSchema,
+  AgentTurnInputContentSchema,
+  AgentTurnInterruptionInputSchema,
+  AgentTurnRunInputSchema
+} from "../zod/turns.js";
+function parseAgentTurnInputContent(input) {
+  return parseWithSchema(AgentTurnInputContentSchema, input);
+}
+function safeParseAgentTurnInputContent(input) {
+  return safeParseWithSchema(AgentTurnInputContentSchema, input);
+}
+function parseAgentTurnRunInput(input) {
+  return parseWithSchema(AgentTurnRunInputSchema, input);
+}
+function safeParseAgentTurnRunInput(input) {
+  return safeParseWithSchema(AgentTurnRunInputSchema, input);
+}
+function parseAgentTurnInterruptionInput(input) {
+  return parseWithSchema(AgentTurnInterruptionInputSchema, input);
+}
+function safeParseAgentTurnInterruptionInput(input) {
+  return safeParseWithSchema(AgentTurnInterruptionInputSchema, input);
+}
+function parseAgentItemSnapshot(input) {
+  return parseWithSchema(AgentItemSnapshotSchema, input);
+}
+function safeParseAgentItemSnapshot(input) {
+  return safeParseWithSchema(AgentItemSnapshotSchema, input);
+}
+export {
+  parseAgentItemSnapshot,
+  parseAgentTurnInputContent,
+  parseAgentTurnInterruptionInput,
+  parseAgentTurnRunInput,
+  safeParseAgentItemSnapshot,
+  safeParseAgentTurnInputContent,
+  safeParseAgentTurnInterruptionInput,
+  safeParseAgentTurnRunInput
+};