@aphrody/m3-ai 3.3.2 → 3.3.5

package/src/types.ts

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: Apache-2.0 AND MIT
+// Derived from SpaceUI (packages/aphrody-spaceui/packages/ai/src/types.ts), MIT.
+
+// Tool execution types
+export type ToolCallStatus = "running" | "completed" | "error";
+
+export interface ToolCallPair {
+  id: string;
+  name: string;
+  argsRaw: string;
+  args: Record<string, unknown> | null;
+  resultRaw: string | null;
+  result: Record<string, unknown> | null;
+  status: ToolCallStatus;
+  /** Human-readable summary provided by live opencode parts */
+  title?: string | null;
+}
+
+// Transcript step types — discriminated union matching the real API schema
+
+export type ActionContent =
+  | { type: "text"; text: string }
+  | { type: "tool_call"; id: string; name: string; args: string };
+
+export type TranscriptStep =
+  | { type: "action"; content: ActionContent[] }
+  | { type: "user_text"; text: string }
+  | { type: "system_text"; text: string }
+  | { type: "tool_result"; call_id: string; name: string; text: string };
+
+// Paired transcript item for rendering
+
+export type TranscriptItem = { kind: "text"; text: string } | { kind: "tool"; pair: ToolCallPair };
+
+// ---------------------------------------------------------------------------
+// Task board types
+// ---------------------------------------------------------------------------
+
+export type TaskStatus = "pending_approval" | "backlog" | "ready" | "in_progress" | "done";
+export type TaskPriority = "critical" | "high" | "medium" | "low";
+
+export interface Subtask {
+  title: string;
+  completed: boolean;
+}
+
+export interface Task {
+  id: string;
+  task_number: number;
+  title: string;
+  description?: string | null;
+  status: TaskStatus;
+  priority: TaskPriority;
+  owner_agent_id: string;
+  assigned_agent_id: string;
+  subtasks: Subtask[];
+  metadata: unknown;
+  worker_id?: string | null;
+  created_by: string;
+  created_at: string;
+  updated_at: string;
+  completed_at?: string | null;
+}
+
+export const TASK_STATUS_ORDER: TaskStatus[] = [
+  "in_progress",
+  "ready",
+  "pending_approval",
+  "backlog",
+  "done",
+];
+
+export const TASK_STATUS_LABEL: Record<TaskStatus, string> = {
+  in_progress: "In Progress",
+  ready: "Ready",
+  pending_approval: "Pending Approval",
+  backlog: "Backlog",
+  done: "Done",
+};
+
+export const TASK_PRIORITY_LABEL: Record<TaskPriority, string> = {
+  critical: "Critical",
+  high: "High",
+  medium: "Medium",
+  low: "Low",
+};
+
+// Domain objects
+export interface TaskInfo {
+  id: string;
+  title: string;
+  status: string;
+  priority: string;
+  assignees: string[];
+  conversation_id?: string;
+}
+
+export interface MemoryInfo {
+  id: string;
+  type: string;
+  content: string;
+  source?: string;
+  edges?: Array<{ target: string; relation: string }>;
+}
+
+export interface CronJobInfo {
+  id: string;
+  name: string;
+  schedule: string;
+  last_run?: string;
+  next_run?: string;
+  status: string;
+}
+
+export interface AgentInfo {
+  id: string;
+  name: string;
+  detail: string;
+  status?: string;
+}
+
+export interface ModelOption {
+  id: string;
+  name: string;
+  provider: string;
+  context_window?: number;
+  capabilities?: string[];
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+export function tryParseJson(text: string): Record<string, unknown> | null {
+  if (!text || text.trim().length === 0) return null;
+  try {
+    const parsed = JSON.parse(text);
+    if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export function isErrorResult(text: string, parsed: Record<string, unknown> | null): boolean {
+  if (parsed?.error) return true;
+  if (parsed?.status === "error") return true;
+  if (parsed?.success === false) return true;
+  if (typeof parsed?.exit_code === "number" && parsed.exit_code !== 0) return true;
+  const lower = text.toLowerCase();
+  return (
+    lower.startsWith("error:") ||
+    lower.startsWith("error -") ||
+    lower.startsWith("failed:") ||
+    lower.startsWith("toolset error:")
+  );
+}
+
+// ---------------------------------------------------------------------------
+// Transcript → TranscriptItem[] pairing
+// ---------------------------------------------------------------------------
+
+/**
+ * Walk a flat TranscriptStep[] and pair each tool_call with its tool_result
+ * via call_id matching, plus emit standalone text steps. Returns an ordered
+ * list of renderable items: text blocks and paired tool calls.
+ */
+export function pairTranscriptSteps(steps: TranscriptStep[]): TranscriptItem[] {
+  const items: TranscriptItem[] = [];
+  const resultsById = new Map<string, { name: string; text: string }>();
+
+  // First pass: index all tool_result steps by call_id
+  for (const step of steps) {
+    if (step.type === "tool_result") {
+      resultsById.set(step.call_id, { name: step.name, text: step.text });
+    }
+  }
+
+  // Second pass: emit items in order
+  for (const step of steps) {
+    if (step.type === "action") {
+      for (const content of step.content) {
+        if (content.type === "text") {
+          items.push({ kind: "text", text: content.text });
+        } else if (content.type === "tool_call") {
+          const result = resultsById.get(content.id);
+          const parsedArgs = tryParseJson(content.args);
+          const parsedResult = result ? tryParseJson(result.text) : null;
+
+          const hasError = result ? isErrorResult(result.text, parsedResult) : false;
+
+          items.push({
+            kind: "tool",
+            pair: {
+              id: content.id,
+              name: content.name,
+              argsRaw: content.args,
+              args: parsedArgs,
+              resultRaw: result?.text ?? null,
+              result: parsedResult,
+              status: result ? (hasError ? "error" : "completed") : "running",
+            },
+          });
+        }
+      }
+    }
+  }
+
+  return items;
+}

package/src/useOpenAIChat.ts

@@ -0,0 +1,126 @@
+// SPDX-License-Identifier: Apache-2.0
+// React hook over `streamChatCompletion`: one conversation streamed from an OpenAI-compatible
+// endpoint, with stop, reset and the `unavailable` status of a model that cannot answer.
+
+"use client";
+
+import { useCallback, useEffect, useReducer, useRef } from "react";
+
+import {
+  type ChatMessage,
+  type ChatStatus,
+  ChatStreamError,
+  chatReducer,
+  initialChatState,
+  newMessageId,
+  streamChatCompletion,
+} from "./openaiChatStream";
+
+export interface UseOpenAIChatOptions {
+  /** API root including `/v1` (e.g. `http://127.0.0.1:8080/v1`). */
+  baseUrl: string;
+  model?: string;
+  fetch?: typeof fetch;
+  headers?: Record<string, string>;
+  initialMessages?: ChatMessage[];
+  /** Messages sent before the conversation on every request (system prompt...). */
+  preamble?: ChatMessage[];
+  /** Extra body fields (`temperature`, `tools`...). */
+  body?: Record<string, unknown>;
+  /** Called with the finished assistant message. */
+  onFinish?: (message: ChatMessage) => void;
+  onError?: (error: ChatStreamError) => void;
+}
+
+export interface UseOpenAIChatResult {
+  messages: ChatMessage[];
+  status: ChatStatus;
+  error: ChatStreamError | null;
+  /** Send a user message and stream the answer. Ignored while streaming. */
+  send: (content: string) => Promise<void>;
+  /** Abort the running request; the partial answer stays. */
+  stop: () => void;
+  /** Abort and clear (or replace) the conversation. */
+  reset: (messages?: ChatMessage[]) => void;
+  setMessages: (messages: ChatMessage[]) => void;
+}
+
+export function useOpenAIChat(options: UseOpenAIChatOptions): UseOpenAIChatResult {
+  const [state, dispatch] = useReducer(chatReducer, options.initialMessages, initialChatState);
+  const controller = useRef<AbortController | null>(null);
+  const latest = useRef({ options, state });
+
+  useEffect(() => {
+    latest.current = { options, state };
+  });
+  useEffect(() => () => controller.current?.abort(), []);
+
+  const send = useCallback(async (content: string) => {
+    const { options: o, state: s } = latest.current;
+    if (s.status === "streaming" || controller.current || !content.trim()) return;
+    const user: ChatMessage = { id: newMessageId(), role: "user", content };
+    const assistantId = newMessageId();
+    const abort = new AbortController();
+    controller.current = abort;
+    dispatch({ type: "start", user, assistantId });
+    let assistant: ChatMessage = { id: assistantId, role: "assistant", content: "" };
+    try {
+      for await (const event of streamChatCompletion({
+        baseUrl: o.baseUrl,
+        model: o.model,
+        messages: [...(o.preamble ?? []), ...s.messages, user],
+        body: o.body,
+        headers: o.headers,
+        fetch: o.fetch,
+        signal: abort.signal,
+      })) {
+        dispatch({ type: "event", assistantId, event });
+        assistant = chatReducer(
+          { messages: [assistant], status: "streaming", error: null },
+          { type: "event", assistantId, event },
+        ).messages[0]!;
+      }
+      dispatch({ type: "finish" });
+      o.onFinish?.(assistant);
+    } catch (cause) {
+      const error =
+        cause instanceof ChatStreamError
+          ? cause
+          : new ChatStreamError("stream", String(cause), { cause });
+      if (error.kind === "aborted" || abort.signal.aborted) {
+        dispatch({ type: "stop" });
+      } else {
+        dispatch({ type: "fail", error });
+        o.onError?.(error);
+      }
+    } finally {
+      if (controller.current === abort) controller.current = null;
+    }
+  }, []);
+
+  const stop = useCallback(() => {
+    controller.current?.abort();
+    controller.current = null;
+    dispatch({ type: "stop" });
+  }, []);
+
+  const reset = useCallback((messages?: ChatMessage[]) => {
+    controller.current?.abort();
+    controller.current = null;
+    dispatch({ type: "reset", messages });
+  }, []);
+
+  const setMessages = useCallback((messages: ChatMessage[]) => {
+    dispatch({ type: "set", messages });
+  }, []);
+
+  return {
+    messages: state.messages,
+    status: state.status,
+    error: state.error,
+    send,
+    stop,
+    reset,
+    setMessages,
+  };
+}