chatkit-bun 0.0.2

package/src/agents/converter.ts

@@ -0,0 +1,290 @@
+import type { AgentInputItem } from "@openai/agents";
+
+import type { Attachment, ThreadItem, UserMessageContent } from "../types/core";
+import { serializeWidget } from "../widgets";
+
+export type UserMessageItem = Extract<ThreadItem, { type: "user_message" }>;
+export type AssistantMessageItem = Extract<ThreadItem, { type: "assistant_message" }>;
+export type ClientToolCallItem = Extract<ThreadItem, { type: "client_tool_call" }>;
+export type WidgetItem = Extract<ThreadItem, { type: "widget" }>;
+export type GeneratedImageItem = Extract<ThreadItem, { type: "generated_image" }>;
+export type StructuredInputItem = Extract<ThreadItem, { type: "structured_input" }>;
+export type TaskItem = Extract<ThreadItem, { type: "task" }>;
+export type WorkflowItem = Extract<ThreadItem, { type: "workflow" }>;
+export type HiddenContextItem = Extract<ThreadItem, { type: "hidden_context_item" }>;
+export type SDKHiddenContextItem = Extract<ThreadItem, { type: "sdk_hidden_context" }>;
+export type EndOfTurnItem = Extract<ThreadItem, { type: "end_of_turn" }>;
+export type UserMessageTagContent = Extract<UserMessageContent, { type: "input_tag" }>;
+
+export type AgentUserMessageItem = Extract<AgentInputItem, { role: "user" }>;
+export type AgentMessageContentPart = Exclude<AgentUserMessageItem["content"], string>[number];
+export type ThreadItemConverterResult = AgentInputItem | AgentInputItem[] | null | undefined;
+
+function normalizeInput(input: ThreadItemConverterResult): AgentInputItem[] {
+  if (input == null) {
+    return [];
+  }
+  return Array.isArray(input) ? input : [input];
+}
+
+function userInputMessage(content: AgentUserMessageItem["content"]): AgentInputItem {
+  return { type: "message", role: "user", content };
+}
+
+function customTaskText(task: Extract<TaskItem["task"], { type: "custom" }>): string | null {
+  const title = task.title ?? "";
+  const content = task.content ?? "";
+  if (!title && !content) {
+    return null;
+  }
+  return title && content ? `${title}: ${content}` : title || content;
+}
+
+function taskMessage(text: string): AgentInputItem {
+  return userInputMessage([
+    {
+      type: "input_text",
+      text: `A message was displayed to the user that the following task was performed:\n<Task>\n${text}\n</Task>`,
+    },
+  ]);
+}
+
+export class ThreadItemConverter {
+  attachmentToMessageContent(_attachment: Attachment): AgentMessageContentPart | Promise<AgentMessageContentPart> {
+    throw new Error(
+      "An Attachment was included in a UserMessageItem but ThreadItemConverter.attachmentToMessageContent was not implemented",
+    );
+  }
+
+  tagToMessageContent(_tag: UserMessageTagContent): AgentMessageContentPart | Promise<AgentMessageContentPart> {
+    throw new Error(
+      "A Tag was included in a UserMessageItem but ThreadItemConverter.tagToMessageContent was not implemented",
+    );
+  }
+
+  generatedImageToInput(item: GeneratedImageItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    if (!item.image) {
+      return null;
+    }
+    return userInputMessage([
+      { type: "input_text", text: "The following image was generated by the agent." },
+      { type: "input_image", image: item.image.url, detail: "auto" },
+    ]);
+  }
+
+  hiddenContextToInput(item: HiddenContextItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    if (typeof item.content !== "string") {
+      throw new Error(
+        "HiddenContextItems with non-string content were present but ThreadItemConverter.hiddenContextToInput was not implemented for non-string content",
+      );
+    }
+    return this.sdkHiddenContextToInput({ ...item, type: "sdk_hidden_context", content: item.content });
+  }
+
+  sdkHiddenContextToInput(item: SDKHiddenContextItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    return userInputMessage([
+      {
+        type: "input_text",
+        text:
+          "Hidden context for the agent (not shown to the user):\n" +
+          `<HiddenContext>\n${item.content}\n</HiddenContext>`,
+      },
+    ]);
+  }
+
+  taskToInput(item: TaskItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    if (item.task.type !== "custom") {
+      return null;
+    }
+    const text = customTaskText(item.task);
+    return text ? taskMessage(text) : null;
+  }
+
+  workflowToInput(item: WorkflowItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    return item.workflow.tasks.flatMap((task) => {
+      if (task.type !== "custom") {
+        return [];
+      }
+      const text = customTaskText(task);
+      return text ? [taskMessage(text)] : [];
+    });
+  }
+
+  async widgetToInput(item: WidgetItem): Promise<ThreadItemConverterResult> {
+    const widget = serializeWidget(item.widget as Parameters<typeof serializeWidget>[0]);
+    return userInputMessage([
+      {
+        type: "input_text",
+        text: `The following graphical UI widget (id: ${item.id}) was displayed to the user:${JSON.stringify(widget)}`,
+      },
+    ]);
+  }
+
+  structuredInputToInput(item: StructuredInputItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    const lines = item.inputs.map((input) => {
+      if (!input.answer) {
+        return `- ${input.question}: unanswered`;
+      }
+      if (input.answer.skipped) {
+        return `- ${input.question}: skipped`;
+      }
+      return `- ${input.question}: ${input.answer.values.join(", ")}`;
+    });
+
+    return userInputMessage([
+      {
+        type: "input_text",
+        text:
+          `A structured input request was displayed to the user with the following status: ${item.status}\n` +
+          "<StructuredInput>\n" +
+          lines.join("\n") +
+          "\n</StructuredInput>",
+      },
+    ]);
+  }
+
+  async userMessageToInput(item: UserMessageItem, isLastMessage = true): Promise<ThreadItemConverterResult> {
+    const messageTextParts: string[] = [];
+    const tagParts: UserMessageTagContent[] = [];
+
+    for (const part of item.content) {
+      if (part.type === "input_text") {
+        messageTextParts.push(part.text);
+      } else {
+        messageTextParts.push(`@${part.text}`);
+        tagParts.push(part);
+      }
+    }
+
+    const userMessage = userInputMessage([
+      { type: "input_text", text: messageTextParts.join("") },
+      ...(await Promise.all(item.attachments.map((attachment) => this.attachmentToMessageContent(attachment)))),
+    ]);
+    const contextMessages: AgentInputItem[] = [];
+
+    if (item.quoted_text && isLastMessage) {
+      contextMessages.push(
+        userInputMessage([
+          {
+            type: "input_text",
+            text: `The user is referring to this in particular: \n${item.quoted_text}`,
+          },
+        ]),
+      );
+    }
+
+    if (tagParts.length > 0) {
+      const seen = new Set<string>();
+      const uniqueTags = tagParts.filter((tag) => {
+        if (seen.has(tag.text)) {
+          return false;
+        }
+        seen.add(tag.text);
+        return true;
+      });
+      const tagContent = await Promise.all(uniqueTags.map((tag) => this.tagToMessageContent(tag)));
+      contextMessages.push(
+        userInputMessage([
+          {
+            type: "input_text",
+            text:
+              "# User-provided context for @-mentions\n" +
+              "- When referencing resolved entities, use their canonical names **without** '@'.\n" +
+              "- The '@' form appears only in user text and should not be echoed.",
+          },
+          ...tagContent,
+        ]),
+      );
+    }
+
+    return [userMessage, ...contextMessages];
+  }
+
+  assistantMessageToInput(item: AssistantMessageItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    return {
+      type: "message",
+      role: "assistant",
+      status: "completed",
+      content: item.content.map((content) => ({ type: "output_text", text: content.text })),
+    };
+  }
+
+  clientToolCallToInput(item: ClientToolCallItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    if (item.status === "pending") {
+      return null;
+    }
+    return [
+      {
+        type: "function_call",
+        name: item.name,
+        callId: item.call_id,
+        arguments: JSON.stringify(item.arguments),
+      },
+      {
+        type: "function_call_result",
+        name: item.name,
+        callId: item.call_id,
+        status: "completed",
+        output: JSON.stringify(item.output ?? null),
+      },
+    ];
+  }
+
+  endOfTurnToInput(_item: EndOfTurnItem): ThreadItemConverterResult | Promise<ThreadItemConverterResult> {
+    return null;
+  }
+
+  async toAgentInput(threadItems: ThreadItem | readonly ThreadItem[]): Promise<AgentInputItem[]> {
+    const items = Array.isArray(threadItems) ? [...threadItems] : [threadItems];
+    const lastUserMessageIndex = items.findLastIndex((item) => item.type === "user_message");
+    const output: AgentInputItem[] = [];
+
+    for (const [index, item] of items.entries()) {
+      switch (item.type) {
+        case "user_message":
+          output.push(...normalizeInput(await this.userMessageToInput(item, index === lastUserMessageIndex)));
+          break;
+        case "assistant_message":
+          output.push(...normalizeInput(await this.assistantMessageToInput(item)));
+          break;
+        case "widget":
+          output.push(...normalizeInput(await this.widgetToInput(item)));
+          break;
+        case "generated_image":
+          output.push(...normalizeInput(await this.generatedImageToInput(item)));
+          break;
+        case "hidden_context_item":
+          output.push(...normalizeInput(await this.hiddenContextToInput(item)));
+          break;
+        case "sdk_hidden_context":
+          output.push(...normalizeInput(await this.sdkHiddenContextToInput(item)));
+          break;
+        case "client_tool_call":
+          output.push(...normalizeInput(await this.clientToolCallToInput(item)));
+          break;
+        case "structured_input":
+          output.push(...normalizeInput(await this.structuredInputToInput(item)));
+          break;
+        case "task":
+          output.push(...normalizeInput(await this.taskToInput(item)));
+          break;
+        case "workflow":
+          output.push(...normalizeInput(await this.workflowToInput(item)));
+          break;
+        case "end_of_turn":
+          output.push(...normalizeInput(await this.endOfTurnToInput(item)));
+          break;
+        default:
+          break;
+      }
+    }
+
+    return output;
+  }
+}
+
+const defaultThreadItemConverter = new ThreadItemConverter();
+
+export function simpleToAgentInput(threadItems: ThreadItem | readonly ThreadItem[]): Promise<AgentInputItem[]> {
+  return defaultThreadItemConverter.toAgentInput(threadItems);
+}

package/src/agents/index.ts

@@ -0,0 +1,25 @@
+export { ResponseStreamConverter, defaultResponseStreamConverter } from "./annotations";
+export type { ResponseStreamConverterOptions } from "./annotations";
+export { accumulateText } from "./accumulate";
+export type { AccumulatableTextWidget } from "./accumulate";
+export { ThreadItemConverter, simpleToAgentInput } from "./converter";
+export type {
+  AgentMessageContentPart,
+  AgentUserMessageItem,
+  AssistantMessageItem,
+  ClientToolCallItem,
+  EndOfTurnItem,
+  GeneratedImageItem,
+  HiddenContextItem,
+  SDKHiddenContextItem,
+  StructuredInputItem,
+  TaskItem,
+  ThreadItemConverterResult,
+  UserMessageItem,
+  UserMessageTagContent,
+  WidgetItem,
+  WorkflowItem,
+} from "./converter";
+export { AgentContext, ClientToolCall } from "./context";
+export { streamAgentResponse } from "./stream";
+export type { AgentContextOptions, AgentStreamInput, StreamAgentResponseOptions } from "./types";