acp-sdk/dist/models/models.js

Agent Communication Protocol SDK

import * as z from 'zod';
import { ErrorModel } from './errors.js';
import { nullishObject, createSchemaTypePredicate } from './utils.js';
import { ACPError } from '../client/errors.js';
import { PlatformUIAnnotation } from './platform.js';

const AnyModel = z.record(z.any());
const Author = z.object({
  name: z.string(),
  email: z.string().nullish(),
  url: z.string().url().nullish()
});
const Contributor = z.object({
  name: z.string(),
  email: z.string().nullish(),
  url: z.string().url().nullish()
});
const LinkType = z.enum([
  "source-code",
  "container-image",
  "homepage",
  "documentation"
]);
const Link = z.object({
  type: LinkType,
  url: z.string().url()
});
const DependencyType = z.enum(["agent", "tool", "model"]);
const Dependency = z.object({
  type: DependencyType,
  name: z.string()
});
const Capability = z.object({
  name: z.string(),
  description: z.string()
});
const Annotations = z.object({
  beeai_ui: PlatformUIAnnotation.nullish()
});
const Metadata = nullishObject(
  z.object({
    annotations: Annotations,
    documentation: z.string(),
    license: z.string(),
    programming_language: z.string(),
    natural_languages: z.array(z.string()),
    framework: z.string(),
    capabilities: z.array(Capability),
    domains: z.array(z.string()),
    tags: z.array(z.string()),
    created_at: z.string().datetime(),
    updated_at: z.string().datetime(),
    author: Author,
    contributors: z.array(Contributor),
    links: z.array(Link),
    dependencies: z.array(Dependency),
    recommended_models: z.array(z.string())
  })
).passthrough();
const CitationMetadata = z.object({
  kind: z.literal("citation").default("citation"),
  start_index: z.number().int().nullish(),
  end_index: z.number().int().nullish(),
  url: z.string().nullish(),
  title: z.string().nullish(),
  description: z.string().nullish()
});
const TrajectoryMetadata = z.object({
  kind: z.literal("trajectory").default("trajectory"),
  message: z.string().nullish(),
  tool_name: z.string().nullish(),
  tool_input: AnyModel.nullish(),
  tool_output: AnyModel.nullish()
});
const BaseMessagePart = z.object({
  name: z.string().nullish(),
  content_type: z.string().nullish().default("text/plain"),
  content: z.string().nullish(),
  content_encoding: z.enum(["plain", "base64"]).nullish().default("plain"),
  content_url: z.string().url().nullish(),
  metadata: z.union([CitationMetadata, TrajectoryMetadata]).nullish()
}).passthrough();
const refineMessagePart = (val, ctx) => {
  if (val.content != null && val.content_url != null) {
    ctx.addIssue({
      code: z.ZodIssueCode.custom,
      message: "Only one of content or content_url can be provided"
    });
  }
  return z.NEVER;
};
const MessagePart = BaseMessagePart.superRefine(refineMessagePart);
const isMessagePart = createSchemaTypePredicate(MessagePart);
const Artifact = BaseMessagePart.required({ name: true }).superRefine(
  refineMessagePart
);
const Message = z.object({
  role: z.string().regex(/^(user|agent(\/[a-zA-Z0-9_\-]+)?)$/).default("user"),
  parts: z.array(MessagePart),
  created_at: z.string().datetime().nullable().default(() => (/* @__PURE__ */ new Date()).toISOString()),
  completed_at: z.string().datetime().nullable().default(() => (/* @__PURE__ */ new Date()).toISOString())
});
const isMessage = createSchemaTypePredicate(Message);
function concatMessages(lhs, rhs) {
  if (lhs.role != rhs.role) {
    throw new Error("Message roles must match for concatenation");
  }
  return {
    role: lhs.role,
    parts: [...lhs.parts, ...rhs.parts],
    created_at: lhs.created_at != null && rhs.created_at != null ? lhs.created_at < rhs.created_at ? lhs.created_at : rhs.created_at : null,
    completed_at: lhs.completed_at != null && rhs.completed_at != null ? lhs.completed_at > rhs.completed_at ? lhs.completed_at : rhs.completed_at : null
  };
}
function compressMessage(message) {
  const canBeJoined = (a, b) => {
    return a.name == null && b.name == null && a.content_type === "text/plain" && b.content_type === "text/plain" && a.content_encoding === "plain" && b.content_encoding === "plain" && a.content_url == null && b.content_url == null;
  };
  const join = (a, b) => ({
    name: null,
    content_type: "text/plain",
    content: (a.content ?? "") + (b.content ?? ""),
    content_encoding: "plain",
    content_url: null
  });
  const compressedParts = [];
  for (const part of message.parts) {
    if (compressedParts.length > 0 && canBeJoined(compressedParts[compressedParts.length - 1], part)) {
      const last = compressedParts.pop();
      compressedParts.push(join(last, part));
    } else {
      compressedParts.push(part);
    }
  }
  return { ...message, parts: compressedParts };
}
const UUID = z.string().uuid();
const AgentName = z.string();
const RunId = UUID;
const SessionId = UUID;
const RunMode = z.enum(["sync", "async", "stream"]);
const RunStatus = z.enum([
  "created",
  "in-progress",
  "awaiting",
  "cancelling",
  "cancelled",
  "completed",
  "failed"
]);
function isTerminalRunStatus(status) {
  return status === "completed" || status === "cancelled" || status === "failed";
}
const MessageAwaitRequest = z.object({
  type: z.literal("message"),
  message: Message
});
const MessageAwaitResume = z.object({
  type: z.literal("message"),
  message: Message
});
const AwaitRequest = MessageAwaitRequest;
const AwaitResume = MessageAwaitResume;
const Run = z.object({
  run_id: RunId,
  agent_name: AgentName,
  session_id: SessionId.nullish(),
  status: RunStatus.default("created"),
  await_request: AwaitRequest.nullish(),
  output: z.array(Message).default([]),
  error: ErrorModel.nullish(),
  created_at: z.string().datetime().default(() => (/* @__PURE__ */ new Date()).toISOString()),
  finished_at: z.string().datetime().nullish()
});
function throwForRunStatus(run) {
  if (run.status === "cancelled") {
    throw new DOMException("Run has been cancelled", "AbortError");
  }
  if (run.status === "failed") {
    throw new ACPError(run.error);
  }
  return run;
}
const AgentManifest = z.object({
  name: AgentName,
  description: z.string().nullish(),
  input_content_types: z.array(z.string()).min(1),
  output_content_types: z.array(z.string()).min(1),
  metadata: Metadata.default({})
});
const MessageCreatedEvent = z.object({
  type: z.literal("message.created"),
  message: Message
});
const MessagePartEvent = z.object({
  type: z.literal("message.part"),
  part: MessagePart
});
const MessageCompletedEvent = z.object({
  type: z.literal("message.completed"),
  message: Message
});
const RunAwaitingEvent = z.object({
  type: z.literal("run.awaiting"),
  run: Run
});
const GenericEvent = z.object({
  type: z.literal("generic"),
  generic: AnyModel
});
const RunCreatedEvent = z.object({
  type: z.literal("run.created"),
  run: Run
});
const RunInProgressEvent = z.object({
  type: z.literal("run.in-progress"),
  run: Run
});
const RunFailedEvent = z.object({
  type: z.literal("run.failed"),
  run: Run
});
const RunCancelledEvent = z.object({
  type: z.literal("run.cancelled"),
  run: Run
});
const RunCompletedEvent = z.object({
  type: z.literal("run.completed"),
  run: Run
});
const ErrorEvent = z.object({
  type: z.literal("error"),
  error: ErrorModel
});
const Event = z.discriminatedUnion("type", [
  MessageCreatedEvent,
  MessagePartEvent,
  MessageCompletedEvent,
  RunAwaitingEvent,
  GenericEvent,
  RunCreatedEvent,
  RunInProgressEvent,
  RunFailedEvent,
  RunCancelledEvent,
  RunCompletedEvent,
  ErrorEvent
]);

export { AgentManifest, AgentName, Annotations, AnyModel, Artifact, Author, AwaitRequest, AwaitResume, Capability, CitationMetadata, Contributor, Dependency, DependencyType, ErrorEvent, Event, GenericEvent, Link, LinkType, Message, MessageAwaitRequest, MessageAwaitResume, MessageCompletedEvent, MessageCreatedEvent, MessagePart, MessagePartEvent, Metadata, Run, RunAwaitingEvent, RunCancelledEvent, RunCompletedEvent, RunCreatedEvent, RunFailedEvent, RunId, RunInProgressEvent, RunMode, RunStatus, SessionId, TrajectoryMetadata, compressMessage, concatMessages, isMessage, isMessagePart, isTerminalRunStatus, throwForRunStatus };
//# sourceMappingURL=models.js.map
//# sourceMappingURL=models.js.map