@capekai/core 1.0.0

package/src/core/error-handling.ts

@@ -0,0 +1,18 @@
+import type { AuthErrorMessage, ContextOverflowErrorMessage, InvalidRequestErrorMessage, ErrorMessage } from '@capekai/types';
+import { ApiErrorType, ERROR_AUTH, ERROR_INVALID_REQUEST, ERROR_CHAT_FAILED } from '../utils/errors';
+import type { ClassifiedError } from '../utils/errors';
+
+export type ErrorEvent = AuthErrorMessage | ContextOverflowErrorMessage | InvalidRequestErrorMessage | ErrorMessage;
+
+export function createErrorEvent(classified: ClassifiedError): ErrorEvent {
+  switch (classified.type) {
+    case ApiErrorType.Authentication:
+      return { type: 'error.auth', code: ERROR_AUTH, message: classified.message };
+    case ApiErrorType.ContextOverflow:
+      return { type: 'error.context_overflow', code: 'context_overflow', message: classified.message };
+    case ApiErrorType.InvalidRequest:
+      return { type: 'error.invalid_request', code: ERROR_INVALID_REQUEST, message: classified.message };
+    default:
+      return { type: 'error', code: ERROR_CHAT_FAILED, message: classified.message };
+  }
+}

package/src/core/fork.ts

@@ -0,0 +1,103 @@
+import type { Message, MessageWithParts, Part, Session } from '@capekai/types';
+import {
+  createMessage,
+  createPart,
+  createSession,
+  getSession,
+  getWorkspaceAutoApproveSeverity,
+  listMessagesWithParts,
+} from '../storage/runtime';
+
+interface ForkOptions {
+  sessionId: string;
+  targetMessageId: string;
+  title?: string;
+}
+
+interface ForkResult {
+  forkedSession: Session;
+  messages: MessageWithParts[];
+}
+
+function generateId(): string {
+  return crypto.randomUUID();
+}
+
+function copyMessage(
+  message: Message,
+  newSessionId: string,
+  newMessageId: string,
+  idMap: Map<string, string>,
+): Message {
+  if (message.role === 'assistant') {
+    const parentId = (message as { parentId?: string }).parentId;
+    return {
+      ...message,
+      id: newMessageId,
+      sessionId: newSessionId,
+      status: 'completed' as const,
+      ...(parentId ? { parentId: idMap.get(parentId) ?? parentId } : {}),
+    };
+  }
+  return {
+    ...message,
+    id: newMessageId,
+    sessionId: newSessionId,
+  };
+}
+
+function copyPart(part: Part, newMessageId: string, newPartId: string): Part {
+  const { id: _oldId, messageId: _oldMsgId, ...rest } = part;
+  return {
+    ...rest,
+    id: newPartId,
+    messageId: newMessageId,
+  } as Part;
+}
+
+export async function forkSession(options: ForkOptions): Promise<ForkResult> {
+  const { sessionId, targetMessageId, title } = options;
+  const sourceSession = await getSession(sessionId);
+  if (!sourceSession) throw new Error('Source session not found');
+
+  const allMessages = await listMessagesWithParts(sessionId);
+  const targetIndex = allMessages.findIndex((entry) => entry.message.id === targetMessageId);
+  if (targetIndex === -1) throw new Error('Target message not found');
+
+  const messagesToFork = allMessages.slice(0, targetIndex + 1);
+  const forkedSession = await createSession({
+    id: generateId(),
+    workspaceId: sourceSession.workspaceId,
+    preconfigId: sourceSession.preconfigId,
+    title: title || `${sourceSession.title || 'Untitled'} (fork)`,
+    status: 'active',
+    metadata: { ...(sourceSession.metadata || {}), forkedFrom: sessionId },
+    parentId: null,
+    agentName: null,
+    selectedModel: sourceSession.selectedModel,
+    selectedProvider: sourceSession.selectedProvider,
+    promptTokens: sourceSession.promptTokens,
+    completionTokens: sourceSession.completionTokens,
+    totalTokens: sourceSession.totalTokens,
+    autoApproveSeverity: sourceSession.autoApproveSeverity ?? await getWorkspaceAutoApproveSeverity(sourceSession.workspaceId),
+  });
+
+  const forkedMessages: MessageWithParts[] = [];
+  const idMap = new Map<string, string>();
+  for (const { message } of messagesToFork) idMap.set(message.id, generateId());
+
+  for (const { message, parts } of messagesToFork) {
+    const newMessageId = idMap.get(message.id)!;
+    const newMessage = copyMessage(message, forkedSession.id, newMessageId, idMap);
+    await createMessage(newMessage);
+    const newParts: Part[] = [];
+    for (const part of parts) {
+      const newPart = copyPart(part, newMessageId, generateId());
+      await createPart(newPart, forkedSession.id);
+      newParts.push(newPart);
+    }
+    forkedMessages.push({ message: newMessage, parts: newParts });
+  }
+
+  return { forkedSession, messages: forkedMessages };
+}

package/src/core/interrupt.ts

@@ -0,0 +1,192 @@
+import type { InterruptReason, SessionInterruptResult } from '@capekai/types';
+import { isSandboxActive } from '../runtime/host-dependencies';
+import { getSandboxController } from '../sandbox/controller';
+import { getChildSessions, getSession, updateSession } from '../storage/runtime';
+import { rejectPendingAsksBySession } from '../permission/ask-user-api';
+
+interface ToolExecution {
+  controller: AbortController;
+  listener: () => void;
+}
+
+interface SessionAbortContext {
+  sessionId: string;
+  parentId?: string;
+  controller: AbortController;
+  toolControllers: Map<string, ToolExecution>;
+  childSessionIds: Set<string>;
+  parentAbortListener?: () => void;
+}
+
+export class InterruptManager {
+  private sessionContexts = new Map<string, SessionAbortContext>();
+  private pendingParentLinks = new Map<string, Promise<void>>();
+
+  registerSession(sessionId: string, parentId?: string): AbortController {
+    if (this.sessionContexts.has(sessionId)) {
+      throw new Error(`Session ${sessionId} already has an active execution`);
+    }
+
+    const controller = new AbortController();
+    const context: SessionAbortContext = {
+      sessionId,
+      controller,
+      toolControllers: new Map(),
+      childSessionIds: new Set(),
+    };
+
+    this.sessionContexts.set(sessionId, context);
+
+    const linkToParent = (resolvedParentId: string): void => {
+      const parentContext = this.sessionContexts.get(resolvedParentId);
+      if (!parentContext) return;
+      parentContext.childSessionIds.add(sessionId);
+      const listener = () => {
+        void this.interruptSession(sessionId, 'cascade');
+      };
+      context.parentId = resolvedParentId;
+      context.parentAbortListener = listener;
+      parentContext.controller.signal.addEventListener('abort', listener);
+    };
+
+    if (parentId) {
+      linkToParent(parentId);
+    } else {
+      const pending = getSession(sessionId).then(session => {
+        if (session?.parentId) linkToParent(session.parentId);
+      }).catch((err: unknown) => {
+        console.error('[interrupt] Failed to resolve session parent', err);
+      });
+      this.pendingParentLinks.set(sessionId, pending);
+      void pending.finally(() => {
+        if (this.pendingParentLinks.get(sessionId) === pending) this.pendingParentLinks.delete(sessionId);
+      });
+    }
+
+    return controller;
+  }
+
+  registerToolExecution(sessionId: string, toolCallId: string): AbortController {
+    const context = this.sessionContexts.get(sessionId);
+
+    const toolController = new AbortController();
+
+    if (context) {
+      const listener = () => {
+        toolController.abort();
+      };
+      context.toolControllers.set(toolCallId, { controller: toolController, listener });
+      context.controller.signal.addEventListener('abort', listener);
+    }
+
+    return toolController;
+  }
+
+  async interruptSession(
+    sessionId: string,
+    _reason: InterruptReason = 'user_request'
+  ): Promise<SessionInterruptResult> {
+    const context = this.sessionContexts.get(sessionId);
+    const cascadedTo: string[] = [];
+    const interruptedTools: string[] = [];
+    const rejectedAsks: string[] = [];
+    await Promise.all(this.pendingParentLinks.values());
+
+    if (context) {
+      for (const [toolCallId, { controller: toolController }] of context.toolControllers) {
+        if (!toolController.signal.aborted) {
+          toolController.abort();
+          interruptedTools.push(toolCallId);
+        }
+      }
+
+      if (!context.controller.signal.aborted) {
+        context.controller.abort();
+      }
+
+      for (const childId of context.childSessionIds) {
+        cascadedTo.push(childId);
+      }
+    }
+
+    // Reject any pending asks for this session to unblock waiting tool executions
+    const pendingAskIds = await rejectPendingAsksBySession(sessionId);
+    rejectedAsks.push(...pendingAskIds);
+
+    // Reject any pending sandbox calls for this session to unblock waitForResponse()
+    if (isSandboxActive()) {
+      getSandboxController().rejectAllPendingForSession(sessionId);
+    }
+
+    // Only set subagentStatus for actual subagent sessions (those with a parentId)
+    // Main sessions should not have their status changed to error on interrupt
+    const session = await getSession(sessionId);
+    if (session?.parentId) {
+      await updateSession(sessionId, {
+        subagentStatus: 'interrupted',
+      });
+    }
+
+    const childSessions = await getChildSessions(sessionId);
+    for (const child of childSessions) {
+      if (child.subagentStatus === 'running') {
+        const childResult = await this.interruptSession(child.id, 'cascade');
+        cascadedTo.push(...childResult.cascadedTo.filter(id => !cascadedTo.includes(id)));
+        interruptedTools.push(...childResult.interruptedTools);
+        rejectedAsks.push(...childResult.rejectedAsks);
+      }
+    }
+
+    return {
+      sessionId,
+      success: true,
+      cascadedTo: [...new Set(cascadedTo)],
+      interruptedTools: [...new Set(interruptedTools)],
+      rejectedAsks: [...new Set(rejectedAsks)],
+    };
+  }
+
+  isSessionActive(sessionId: string): boolean {
+    const context = this.sessionContexts.get(sessionId);
+    return context !== undefined && !context.controller.signal.aborted;
+  }
+
+  isSessionInterrupted(sessionId: string): boolean {
+    const context = this.sessionContexts.get(sessionId);
+    return context?.controller.signal.aborted ?? false;
+  }
+
+  unregisterSession(sessionId: string): void {
+    const context = this.sessionContexts.get(sessionId);
+    if (context) {
+      // Remove this session's abort listener from parent's signal
+      if (context.parentAbortListener && context.parentId) {
+        const parentContext = this.sessionContexts.get(context.parentId);
+        if (parentContext) {
+          parentContext.controller.signal.removeEventListener('abort', context.parentAbortListener);
+          parentContext.childSessionIds.delete(sessionId);
+        }
+      }
+
+      // Remove all tool execution listeners from this session's signal
+      for (const { listener } of context.toolControllers.values()) {
+        context.controller.signal.removeEventListener('abort', listener);
+      }
+    }
+
+    this.sessionContexts.delete(sessionId);
+  }
+
+  unregisterToolExecution(sessionId: string, toolCallId: string): void {
+    const context = this.sessionContexts.get(sessionId);
+    if (context) {
+      const toolExec = context.toolControllers.get(toolCallId);
+      if (toolExec) {
+        context.controller.signal.removeEventListener('abort', toolExec.listener);
+      }
+      context.toolControllers.delete(toolCallId);
+    }
+  }
+}
+
+export const interruptManager = new InterruptManager();

package/src/core/message-utils.ts

@@ -0,0 +1,261 @@
+import type { MessageWithParts, CompactionPart, ImagePart, FilePart } from '@capekai/types';
+import type { ModelMessage } from 'ai';
+import { isTextPart, isToolPart, isImagePart, isFilePart, parseToolInput } from './part-utils';
+import { stripVisualization } from '../utils/strip-visualization';
+import { getAttachment } from '../storage/runtime';
+import { isToolOutputArtifactReference, RETRIEVE_TOOL_OUTPUT_NAME } from '../tool-output/policy';
+
+type AiSdkContent = string | Array<{
+  type: 'text' | 'tool-call' | 'tool-result' | 'image' | 'file';
+  text?: string;
+  toolCallId?: string;
+  toolName?: string;
+  input?: unknown;
+  value?: unknown;
+  output?: unknown;
+  image?: URL | Uint8Array;
+  data?: URL | Uint8Array;
+  mediaType?: string;
+  filename?: string;
+}>;
+
+interface ModelCapabilities {
+  input?: {
+    text?: boolean;
+    image?: boolean;
+    video?: boolean;
+    file?: string[];
+  };
+}
+
+async function resolveAttachmentPath(part: ImagePart | FilePart): Promise<{ absolutePath: string; mimeType: string } | null> {
+  const urlWithoutQuery = part.url.split('?')[0];
+  const match = urlWithoutQuery.match(/^\/api\/sessions\/([^/]+)\/attachments\/([^/]+)\/content$/);
+  if (!match) return null;
+
+  const [, sessionId, attachmentId] = match;
+  try {
+    const attachment = await getAttachment(sessionId, attachmentId);
+    if (!attachment) return null;
+    return { absolutePath: attachment.absolutePath, mimeType: attachment.mimeType };
+  } catch {
+    return null;
+  }
+}
+
+export async function convertToAiSdkMessages(
+  messages: MessageWithParts[],
+  modelCapabilities?: ModelCapabilities,
+): Promise<ModelMessage[]> {
+  const result: { role: 'user' | 'assistant' | 'system' | 'tool'; content: AiSdkContent }[] = [];
+
+  for (const msgWithParts of messages) {
+    const msg = msgWithParts.message;
+    const parts = msgWithParts.parts;
+
+    const textBlocks: string[] = [];
+    const toolCallBlocks: Array<{
+      type: 'tool-call';
+      toolCallId: string;
+      toolName: string;
+      input: unknown;
+    }> = [];
+    const toolResultBlocks: Array<{
+      type: 'tool-result';
+      toolCallId: string;
+      toolName: string;
+      output: unknown;
+    }> = [];
+    const imageParts: ImagePart[] = [];
+    const fileParts: FilePart[] = [];
+
+    const hasCompactionTrigger = parts.some(p => p.type === 'compaction');
+
+    if (msg.role === 'assistant' && (msg.mode === 'compact_failed' || msg.mode === 'retry_failed')) {
+      continue;
+    }
+
+    for (const part of parts) {
+      if (isTextPart(part)) {
+        textBlocks.push(part.text);
+      } else if (part.type === 'compaction') {
+        const compactionPart = part as CompactionPart;
+        if (compactionPart.overflow) {
+          textBlocks.push('Continue from where we left off, summarizing what we did so far.');
+        } else {
+          textBlocks.push('What did we do so far?');
+        }
+      } else if (isToolPart(part)) {
+        const toolPart = part;
+
+        toolCallBlocks.push({
+          type: 'tool-call' as const,
+          toolCallId: toolPart.callId,
+          toolName: toolPart.name,
+          input: parseToolInput(toolPart.state.input),
+        });
+
+        if (toolPart.state.status === 'completed') {
+          const isCompacted = !!(toolPart.state as { compactedAt?: number }).compactedAt;
+          const isSkillTool = toolPart.name === 'skill';
+
+          if (isCompacted && !isSkillTool) {
+            const output = stripVisualization(toolPart.state.output);
+            const value = isToolOutputArtifactReference(output)
+              ? {
+                ...output,
+                preview: '[Old tool result content cleared]',
+                message: `[Old tool result content cleared] Exact output remains available with ${RETRIEVE_TOOL_OUTPUT_NAME} using artifactId ${output.artifactId}.`,
+              }
+              : '[Old tool result content cleared]';
+            toolResultBlocks.push({
+              type: 'tool-result' as const,
+              toolCallId: toolPart.callId,
+              toolName: toolPart.name,
+              output: isToolOutputArtifactReference(output)
+                ? { type: 'json' as const, value }
+                : { type: 'text' as const, value },
+            });
+          } else {
+            toolResultBlocks.push({
+              type: 'tool-result' as const,
+              toolCallId: toolPart.callId,
+              toolName: toolPart.name,
+              output: { type: 'json' as const, value: stripVisualization(toolPart.state.output) },
+            });
+          }
+        } else if (toolPart.state.status === 'error') {
+          toolResultBlocks.push({
+            type: 'tool-result' as const,
+            toolCallId: toolPart.callId,
+            toolName: toolPart.name,
+            output: { type: 'text' as const, value: JSON.stringify(stripVisualization({ error: toolPart.state.error })) },
+          });
+        } else {
+          // Handle 'pending', 'running', or 'interrupted' tool states
+          // These can occur when a session was interrupted or crashed mid-execution.
+          // Synthesize an error result so the AI SDK gets a valid tool-result for every tool-call.
+          const statusLabel = toolPart.state.status === 'interrupted'
+            ? 'interrupted'
+            : `${toolPart.state.status} (session interrupted)`;
+          toolResultBlocks.push({
+            type: 'tool-result' as const,
+            toolCallId: toolPart.callId,
+            toolName: toolPart.name,
+            output: { type: 'text' as const, value: JSON.stringify({ error: `Tool execution was ${statusLabel}` }) },
+          });
+        }
+      } else if (isImagePart(part)) {
+        if (modelCapabilities?.input?.image) {
+          imageParts.push(part);
+        } else {
+          const attachmentRecord = await resolveAttachmentPath(part);
+          const fallbackText = attachmentRecord
+            ? `User attached an image.\nFile path: ${attachmentRecord.absolutePath}\nIf the image contents matter, ask the user to describe it or inspect the file if your runtime supports access to that path.`
+            : 'User attached an image (file path unavailable).';
+          textBlocks.push(fallbackText);
+        }
+      } else if (isFilePart(part)) {
+        if (modelCapabilities?.input?.file && modelCapabilities.input.file.includes(part.mimeType)) {
+          fileParts.push(part);
+        } else {
+          const attachmentRecord = await resolveAttachmentPath(part);
+          const fallbackText = attachmentRecord
+            ? `User attached a file: ${part.filename || 'unnamed'} (type: ${part.mimeType}).\nFile path: ${attachmentRecord.absolutePath}\nIf the file contents matter, ask the user to describe it or inspect the file if your runtime supports access to that path.`
+            : `User attached a file: ${part.filename || 'unnamed'} (type: ${part.mimeType}).`;
+          textBlocks.push(fallbackText);
+        }
+      }
+    }
+
+    const hasText = textBlocks.length > 0;
+    const hasToolCalls = toolCallBlocks.length > 0;
+    const hasImages = imageParts.length > 0;
+    const hasFiles = fileParts.length > 0;
+    const hasContentParts = hasText || hasImages || hasFiles || hasToolCalls;
+
+    if (!hasContentParts) {
+      continue;
+    }
+
+    const contentParts: Array<{
+      type: 'text' | 'tool-call' | 'image' | 'file';
+      text?: string;
+      toolCallId?: string;
+      toolName?: string;
+      input?: unknown;
+      image?: URL | Uint8Array;
+      data?: URL | Uint8Array;
+      mimeType?: string;
+      mediaType?: string;
+      filename?: string;
+    }> = [];
+
+    if (hasText) {
+      contentParts.push({ type: 'text', text: textBlocks.join('\n\n') });
+    }
+
+    for (const imgPart of imageParts) {
+      const resolved = await resolveAttachmentPath(imgPart);
+      if (resolved) {
+        try {
+          const file = Bun.file(resolved.absolutePath);
+          const buffer = await file.arrayBuffer();
+          contentParts.push({ type: 'image', image: new Uint8Array(buffer), mimeType: resolved.mimeType });
+        } catch {
+          // skip if file can't be read
+        }
+      }
+    }
+
+    for (const filePart of fileParts) {
+      const resolved = await resolveAttachmentPath(filePart);
+      if (resolved) {
+        try {
+          const file = Bun.file(resolved.absolutePath);
+          const buffer = await file.arrayBuffer();
+          contentParts.push({
+            type: 'file',
+            data: new Uint8Array(buffer),
+            mediaType: resolved.mimeType,
+            filename: filePart.filename || 'unnamed',
+          });
+        } catch {
+          // skip if file can't be read
+        }
+      }
+    }
+
+    for (const toolCall of toolCallBlocks) {
+      contentParts.push({
+        type: 'tool-call',
+        toolCallId: toolCall.toolCallId,
+        toolName: toolCall.toolName,
+        input: toolCall.input,
+      });
+    }
+
+    if (!hasToolCalls && !hasImages && !hasFiles) {
+      const content = textBlocks.join('\n\n');
+      result.push({
+        role: hasCompactionTrigger ? 'user' : (msg.role as 'user' | 'assistant' | 'system'),
+        content,
+      });
+      continue;
+    }
+
+    result.push({
+      role: msg.role as 'user' | 'assistant' | 'system',
+      content: contentParts,
+    });
+
+    for (const toolResult of toolResultBlocks) {
+      result.push({
+        role: 'tool' as const,
+        content: [toolResult],
+      });
+    }
+  }
+
+  return result as unknown as ModelMessage[];
+}