@finalai/agent-definition 0.5.0 → 0.6.0

package/dist/compiler-assets/chunk-ISYIPH2T.ts

@@ -1,120 +0,0 @@
-import {
-  jsonObjectSchema
-} from "./chunk-FU5VHNO4.ts";
-import {
-  stamp
-} from "./chunk-KTBNDKGJ.ts";
-import {
-  array,
-  object,
-  string
-} from "./chunk-KTXTYIF4.ts";
-
-// ../agent-provider/src/channel-context.ts
-var channelInputReceiptSchema = object({
-  inputId: string().min(1),
-  sessionId: string().min(1)
-});
-var channelHandoffReceiptSchema = object({
-  inputId: string().min(1).nullable(),
-  sessionId: string().min(1).nullable()
-});
-var channelAccessors = (platform) => {
-  const operations = () => {
-    if (platform.channelSessions == null)
-      throw new Error("channel session operations are unavailable");
-    return platform.channelSessions;
-  };
-  const handle = (target) => ({
-    inspect: () => operations().inspect(target),
-    resolveSession: () => operations().resolve(target),
-    send: (input) => operations().send(target, input),
-    respond: (input) => operations().respond(target, input),
-    cancel: (input) => operations().cancel(target, input),
-    close: () => operations().close(target),
-    observe: (input) => operations().observe(target, input),
-    setConfigOption: (input) => operations().setConfigOption(target, input),
-    park: () => operations().park(target),
-    getState: () => operations().getState(target),
-    setState: (state) => operations().setState(target, state)
-  });
-  return {
-    from: (address) => handle({ address }),
-    resolveSession: (address) => operations().resolve({ address }),
-    attachSession: (sessionId) => handle({ sessionId }),
-    to: (channel, target) => ({ send: (input) => operations().handoff(channel, target, input) })
-  };
-};
-
-// ../agent-provider/src/semantic-events.ts
-var channelMessageCompletedSchema = object({
-  message: object({ id: string(), content: array(jsonObjectSchema) }),
-  finishReason: string().nullable()
-});
-var channelTurnEventSchema = object({
-  turnId: string(),
-  stopReason: string().nullable().optional()
-});
-
-// src/authoring/channels.ts
-var defineChannel = (definition) => {
-  const {
-    "message.delta": delta,
-    "message.completed": completed,
-    "turn.started": started,
-    "turn.completed": ended,
-    ...raw
-  } = definition.events ?? {};
-  const events = { ...raw };
-  const wrap = (schema, handler) => handler == null ? void 0 : async (event, ctx) => handler(
-    schema.parse(event.data),
-    { ...channelAccessors(ctx.platform), platform: ctx.platform },
-    {
-      sessionId: ctx.sessionId ?? null,
-      turnId: ctx.turn.id,
-      state: ctx.state,
-      config: ctx.config,
-      secrets: ctx.secrets
-    }
-  );
-  const semantic = {
-    "message.delta": wrap(object({ messageId: string(), delta: jsonObjectSchema }), delta),
-    "message.completed": wrap(channelMessageCompletedSchema, completed),
-    "turn.started": wrap(object({ turnId: string() }), started),
-    "turn.completed": wrap(
-      object({ turnId: string(), stopReason: string().nullable() }),
-      ended
-    )
-  };
-  for (const [kind, handler] of Object.entries(semantic))
-    if (handler != null) events[kind] = handler;
-  const { installed, configure, ...authored } = definition;
-  return stamp(
-    { ...authored, configure: installed == null ? configure : void 0, events },
-    "channel" /* Channel */
-  );
-};
-var disableChannel = () => defineChannel({ disabled: true });
-var route = (method) => (path, handler) => ({
-  method,
-  path,
-  handler
-});
-var GET = route("GET");
-var POST = route("POST");
-var PUT = route("PUT");
-var DELETE = route("DELETE");
-var WS = (path, handler) => ({ method: "WS", path, handler });
-var defineProviderChannel = (definition) => stamp(definition, "channel" /* Channel */);
-
-export {
-  channelAccessors,
-  defineChannel,
-  disableChannel,
-  GET,
-  POST,
-  PUT,
-  DELETE,
-  WS,
-  defineProviderChannel
-};

package/dist/compiler-assets/chunk-JRKGCYWA.ts

@@ -1,87 +0,0 @@
-import {
-  jsonObjectSchema,
-  jsonValueSchema
-} from "./chunk-FU5VHNO4.ts";
-import {
-  _null,
-  array,
-  literal,
-  looseObject,
-  nativeEnum,
-  object,
-  string,
-  union
-} from "./chunk-KTXTYIF4.ts";
-
-// ../agent-provider/src/channel.ts
-var ChannelPrincipalType = /* @__PURE__ */ ((ChannelPrincipalType2) => {
-  ChannelPrincipalType2["User"] = "user";
-  ChannelPrincipalType2["Service"] = "service";
-  return ChannelPrincipalType2;
-})(ChannelPrincipalType || {});
-var channelAuthSchema = object({
-  principalId: string().min(1),
-  principalType: nativeEnum(ChannelPrincipalType),
-  authenticator: string().min(1),
-  // How the agent and the people reading its reply name the principal.
-  displayName: string().min(1).max(200).optional(),
-  attributes: jsonObjectSchema.default({})
-});
-var ConversationKind = /* @__PURE__ */ ((ConversationKind2) => {
-  ConversationKind2["Direct"] = "direct";
-  ConversationKind2["Group"] = "group";
-  return ConversationKind2;
-})(ConversationKind || {});
-var ParticipantKind = /* @__PURE__ */ ((ParticipantKind2) => {
-  ParticipantKind2["User"] = "user";
-  ParticipantKind2["Agent"] = "agent";
-  return ParticipantKind2;
-})(ParticipantKind || {});
-var MessageKind = /* @__PURE__ */ ((MessageKind2) => {
-  MessageKind2["Message"] = "message";
-  MessageKind2["Card"] = "card";
-  return MessageKind2;
-})(MessageKind || {});
-var channelReceiveResultSchema = union([
-  object({ conversationId: string().min(1) }),
-  object({ sessionId: string().min(1) }),
-  _null()
-]);
-var channelMessageInputSchema = object({
-  conversationId: string().min(1),
-  authorParticipantId: string().min(1),
-  kind: nativeEnum(MessageKind).default("message" /* Message */),
-  content: array(jsonObjectSchema).min(1),
-  clientMessageId: string().min(1).nullish(),
-  replyToMessageId: string().min(1).nullish(),
-  threadRootId: string().min(1).nullish(),
-  quotedMessageIds: array(string().min(1)).default([]),
-  mentionedParticipantIds: array(string().min(1)).default([])
-});
-var DecisionKind = /* @__PURE__ */ ((DecisionKind2) => {
-  DecisionKind2["Permission"] = "permission";
-  DecisionKind2["Elicitation"] = "elicitation";
-  return DecisionKind2;
-})(DecisionKind || {});
-var decisionCreatedDataSchema = object({
-  decisionId: string().min(1),
-  kind: nativeEnum(DecisionKind),
-  audienceParticipantIds: array(string()),
-  request: jsonValueSchema
-});
-var decisionResolvedDataSchema = object({
-  decisionId: string().min(1),
-  outcome: jsonValueSchema,
-  respondedBy: channelAuthSchema.nullable().default(null)
-});
-var turnEndSchema = looseObject({
-  sessionUpdate: literal("state_update"),
-  state: literal("idle"),
-  stopReason: string().nullish(),
-  _meta: looseObject({ "final.ai": looseObject({ stopReason: string().nullish() }).nullish() }).nullish()
-});
-
-export {
-  ConversationKind,
-  ParticipantKind
-};