acp-sdk/dist/models/models.cjs

Agent Communication Protocol SDK

'use strict';

var z = require('zod');
var errors_cjs = require('./errors.cjs');
var utils_cjs = require('./utils.cjs');
var errors_cjs$1 = require('../client/errors.cjs');
var platform_cjs = require('./platform.cjs');

function _interopNamespace(e) {
  if (e && e.__esModule) return e;
  var n = Object.create(null);
  if (e) {
    Object.keys(e).forEach(function (k) {
      if (k !== 'default') {
        var d = Object.getOwnPropertyDescriptor(e, k);
        Object.defineProperty(n, k, d.get ? d : {
          enumerable: true,
          get: function () { return e[k]; }
        });
      }
    });
  }
  n.default = e;
  return Object.freeze(n);
}

var z__namespace = /*#__PURE__*/_interopNamespace(z);

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

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