@truefoundry/trueforge-assistant-ui-runtime 0.0.0 → 0.2.0-rc.0

package/dist/server/index.js

@@ -0,0 +1,9 @@
+import {
+  isEventDelta,
+  mergeEventDelta
+} from "../chunk-2SQK6TIO.js";
+export {
+  isEventDelta,
+  mergeEventDelta
+};
+//# sourceMappingURL=index.js.map

package/dist/server/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/package.json

@@ -1,25 +1,88 @@
 {
   "name": "@truefoundry/trueforge-assistant-ui-runtime",
-  "version": "0.0.0",
-  "description": "Placeholder package for TrueForge assistant UI runtime.",
-  "license": "UNLICENSED",
-  "main": "index.js",
-  "files": [
-    "index.js"
-  ],
-  "scripts": {
-    "test": "node --test"
+  "version": "0.2.0-rc.0",
+  "description": "TrueForge agent runtime adapter for assistant-ui",
+  "author": "TrueFoundry",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/truefoundry/trueforge.git",
+    "directory": "packages/assistant-ui-runtime"
+  },
+  "homepage": "https://github.com/truefoundry/trueforge/tree/main/packages/assistant-ui-runtime#readme",
+  "bugs": {
+    "url": "https://github.com/truefoundry/trueforge/issues"
   },
   "keywords": [
-    "trueforge",
     "assistant-ui",
-    "placeholder"
+    "truefoundry",
+    "ai",
+    "agent",
+    "react",
+    "llm",
+    "chat"
   ],
-  "engines": {
-    "node": ">=18"
-  },
   "publishConfig": {
     "access": "public",
-    "tag": "placeholder"
+    "provenance": true
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.js",
+      "default": "./dist/server/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@assistant-ui/core": "^0.2.22",
+    "@assistant-ui/store": "^0.2.21"
+  },
+  "peerDependencies": {
+    "@types/react": "*",
+    "react": "^18 || ^19"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^20",
+    "@types/react": "^19.2.17",
+    "jsdom": "^29.1.1",
+    "react": "^19.2.4",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.9"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint src --fix --cache --cache-location ../../.eslintcache --cache-strategy content",
+    "lint:ci": "eslint src --cache --cache-location ../../.eslintcache",
+    "pack:dry": "pnpm build && pnpm pack --dry-run",
+    "test": "vitest run",
+    "test:file": "vitest run",
+    "typecheck": "tsc --noEmit && pnpm run typecheck:test",
+    "typecheck:test": "tsc --noEmit --project test/tsconfig.json"
   }
-}
+}

package/src/askUserQuestion.ts

@@ -0,0 +1,38 @@
+import type { ToolCall } from './server/index.js';
+
+export function isAskUserQuestionToolCall(toolCall: Pick<ToolCall, 'toolInfo'>): boolean {
+  return toolCall.toolInfo?.type === 'trueforge-system' && toolCall.toolInfo.name === 'ask_user_question';
+}
+
+export interface AskUserQuestionArgs {
+  question?: string;
+  options?: string[];
+}
+
+export function parseAskUserQuestionArgs(argsText: string | undefined): AskUserQuestionArgs {
+  if (!argsText) {
+    return {};
+  }
+  try {
+    const parsed: unknown = JSON.parse(argsText);
+    if (!isUnknownRecord(parsed)) {
+      return {};
+    }
+    const rawQuestion = parsed['question'];
+    const rawOptions = parsed['options'];
+    const question = typeof rawQuestion === 'string' ? rawQuestion : undefined;
+    const options = Array.isArray(rawOptions)
+      ? rawOptions.filter((item): item is string => typeof item === 'string')
+      : undefined;
+    return {
+      ...(question == null ? {} : { question }),
+      ...(options == null ? {} : { options }),
+    };
+  } catch {
+    return {};
+  }
+}
+
+function isUnknownRecord(value: unknown): value is Record<string, unknown> {
+  return value != null && typeof value === 'object' && !Array.isArray(value);
+}

package/src/attachmentAdapter.ts

@@ -0,0 +1,63 @@
+import type { AttachmentAdapter, PendingAttachment } from '@assistant-ui/core';
+
+const bytesToBase64 = (bytes: Uint8Array): string => globalThis.Buffer.from(bytes).toString('base64');
+
+const getFileDataURL = async (file: File): Promise<string> => {
+  if (typeof FileReader === 'undefined') {
+    const buffer = await file.arrayBuffer();
+    return `data:${file.type};base64,${bytesToBase64(new Uint8Array(buffer))}`;
+  }
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      if (typeof reader.result === 'string') {
+        resolve(reader.result);
+      } else {
+        reject(new Error('Attachment reader returned non-text data.'));
+      }
+    };
+    reader.onerror = () => {
+      reject(reader.error ?? new Error('Failed to read attachment.'));
+    };
+    reader.readAsDataURL(file);
+  });
+};
+
+/**
+ * Reads composer files into `CompleteAttachment` `file` parts for send.
+ * Wire via `adapters: { attachments: trueForgeAttachmentAdapter }`.
+ */
+export const trueForgeAttachmentAdapter: AttachmentAdapter = {
+  accept: '*',
+  add({ file }) {
+    return Promise.resolve({
+      id: globalThis.crypto.randomUUID(),
+      type: 'file',
+      name: file.name,
+      file,
+      contentType: file.type,
+      content: [],
+      status: {
+        type: 'requires-action',
+        reason: 'composer-send',
+      },
+    });
+  },
+  async send(attachment: PendingAttachment) {
+    return {
+      ...attachment,
+      status: { type: 'complete' },
+      content: [
+        {
+          type: 'file',
+          mimeType: attachment.contentType ?? '',
+          filename: attachment.name,
+          data: await getFileDataURL(attachment.file),
+        },
+      ],
+    };
+  },
+  remove() {
+    return Promise.resolve();
+  },
+};

package/src/collectPending.ts

@@ -0,0 +1,167 @@
+import type { ThreadAssistantMessagePart, ThreadMessage } from '@assistant-ui/core';
+import type { McpAuthRequiredEvent } from './server/index.js';
+
+import { ROOT_THREAD_ID } from './constants.js';
+import { isMcpServerAuthInfoList, isUnknownRecord } from './messageCustomMetadata.js';
+import { getToolApprovalThreadId, hasPendingToolApproval } from './toolApproval.js';
+import {
+  getToolResponseThreadId,
+  hasPendingToolResponse,
+  type AskUserQuestionInterruptPayload,
+} from './toolResponse.js';
+
+export interface PendingApproval {
+  approvalId: string;
+  threadId: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  argsText: string;
+}
+
+export interface PendingToolResponse {
+  toolCallId: string;
+  threadId: string;
+  toolName: string;
+  args: Record<string, unknown>;
+  argsText: string;
+  question?: string;
+  options?: string[];
+}
+
+type ToolCallPart = Extract<ThreadMessage['content'][number], { type: 'tool-call' }>;
+
+function walkToolCallParts(
+  content: readonly ThreadAssistantMessagePart[],
+  visit: (part: ToolCallPart, threadId: string) => void,
+  threadId: string,
+): void {
+  for (const part of content) {
+    if (part.type !== 'tool-call') {
+      continue;
+    }
+    visit(part, threadId);
+    if (part.messages == null) {
+      continue;
+    }
+    for (const message of part.messages) {
+      if (message.role !== 'assistant') {
+        continue;
+      }
+      const nestedThreadId = getToolApprovalThreadId(message) ?? getToolResponseThreadId(message) ?? threadId;
+      walkToolCallParts(message.content, visit, nestedThreadId);
+    }
+  }
+}
+
+export function collectPendingApprovals(messages: readonly ThreadMessage[]): PendingApproval[] {
+  const pending: PendingApproval[] = [];
+
+  for (const message of messages) {
+    if (message.role !== 'assistant') {
+      continue;
+    }
+    const rootThreadId = getToolApprovalThreadId(message) ?? ROOT_THREAD_ID;
+    walkToolCallParts(
+      message.content,
+      (part, threadId) => {
+        const approval = part.approval;
+        if (approval == null || !hasPendingToolApproval(approval)) {
+          return;
+        }
+        pending.push({
+          approvalId: approval.id,
+          threadId,
+          toolName: part.toolName,
+          args: { ...part.args },
+          argsText: part.argsText,
+        });
+      },
+      rootThreadId,
+    );
+  }
+
+  return pending;
+}
+
+export function collectPendingToolResponses(messages: readonly ThreadMessage[]): PendingToolResponse[] {
+  const pending: PendingToolResponse[] = [];
+
+  for (const message of messages) {
+    if (message.role !== 'assistant') {
+      continue;
+    }
+    const rootThreadId = getToolResponseThreadId(message) ?? ROOT_THREAD_ID;
+    walkToolCallParts(
+      message.content,
+      (part, threadId) => {
+        if (!hasPendingToolResponse(part)) {
+          return;
+        }
+        const payload: AskUserQuestionInterruptPayload | undefined = isUnknownRecord(part.interrupt?.payload)
+          ? {
+              ...(typeof part.interrupt.payload['question'] === 'string'
+                ? { question: part.interrupt.payload['question'] }
+                : {}),
+              ...(Array.isArray(part.interrupt.payload['options']) &&
+              part.interrupt.payload['options'].every(option => typeof option === 'string')
+                ? { options: part.interrupt.payload['options'] }
+                : {}),
+            }
+          : undefined;
+        pending.push({
+          toolCallId: part.toolCallId,
+          threadId,
+          toolName: part.toolName,
+          args: { ...part.args },
+          argsText: part.argsText,
+          ...(payload?.question != null ? { question: payload.question } : {}),
+          ...(payload?.options != null ? { options: payload.options } : {}),
+        });
+      },
+      rootThreadId,
+    );
+  }
+
+  return pending;
+}
+
+export function derivePendingMcpAuth(
+  messages: readonly ThreadMessage[],
+): { mcpServers: McpAuthRequiredEvent['mcpServers'] } | null {
+  for (const message of messages.toReversed()) {
+    if (message.role !== 'assistant') {
+      continue;
+    }
+    if (message.status.type !== 'requires-action') {
+      continue;
+    }
+    const custom = message.metadata.custom;
+    if (custom['pendingMcpAuth'] !== true) {
+      continue;
+    }
+    const servers = custom['mcpServers'];
+    if (!isMcpServerAuthInfoList(servers)) {
+      return { mcpServers: [] };
+    }
+    return { mcpServers: servers };
+  }
+  return null;
+}
+
+/**
+ * Most recent `sandboxId` observed anywhere in the conversation, scanning backward.
+ * Unlike `derivePendingMcpAuth`, this isn't gated on message status: once a sandbox
+ * is created it stays valid for the rest of the session, not just the paused message.
+ */
+export function deriveSandboxId(messages: readonly ThreadMessage[]): string | undefined {
+  for (const message of messages.toReversed()) {
+    if (message.role !== 'assistant') {
+      continue;
+    }
+    const sandboxId = message.metadata.custom['sandboxId'];
+    if (typeof sandboxId === 'string') {
+      return sandboxId;
+    }
+  }
+  return undefined;
+}

package/src/constants.ts

@@ -0,0 +1,2 @@
+/** Gateway root thread id — always the literal `"main"`. */
+export const ROOT_THREAD_ID = 'main';