runtime.ts

import { query, type Options, type SDKMessage } from '@anthropic-ai/claude-agent-sdk';
import {
  agentOutput,
  shouldHandleInvoke,
  uiWidget,
  type AgentInvokeEvent,
  type OpenBotState,
  type PluginFactory,
  type Storage,
} from '@meetopenbot/plugin-sdk';

export interface ClaudeCodeRuntimeOptions {
  /** Claude model alias or full id (e.g. `sonnet`, `claude-opus-4-5`). */
  model?: string;
  /** System prompt prepended to the SDK's default tools/system. */
  system?: string;
  /** Permission mode forwarded to the Claude Agent SDK. */
  permissionMode?: NonNullable<Options['permissionMode']>;
  /** Working directory for the SDK subprocess (falls back to channel cwd). */
  cwd?: string;
  /** Restrict the SDK's built-in tools (Read, Edit, Bash, ...). */
  allowedTools?: string[];
  /** Storage handle for persisting the resume session id across runs. */
  storage?: Storage;
}

interface PersistedClaudeState {
  claudeSessionId?: string;
}

const asRecord = (value: unknown): Record<string, unknown> =>
  value && typeof value === 'object' && !Array.isArray(value)
    ? (value as Record<string, unknown>)
    : {};

const readPersistedSessionId = (state: OpenBotState): string | undefined => {
  const source = state.threadDetails?.state ?? state.channelDetails?.state;
  const record = asRecord(source) as PersistedClaudeState;
  return typeof record.claudeSessionId === 'string' ? record.claudeSessionId : undefined;
};

const persistSessionId = async (
  state: OpenBotState,
  storage: Storage | undefined,
  sessionId: string,
): Promise<void> => {
  if (!storage) return;
  const patch = { claudeSessionId: sessionId };
  if (state.threadId) {
    await storage.patchThreadState({
      channelId: state.channelId,
      threadId: state.threadId,
      state: patch,
    });
    return;
  }
  await storage.patchChannelState({ channelId: state.channelId, state: patch });
};

const AUTH_ERROR_PATTERNS = [
  'api key',
  'apikey',
  'anthropic_api_key',
  'authentication',
  'unauthorized',
  '401',
  'not logged in',
  'login',
  'oauth',
];

const isAuthErrorMessage = (message: string): boolean => {
  const lower = message.toLowerCase();
  return AUTH_ERROR_PATTERNS.some((p) => lower.includes(p));
};

const buildApiKeyWidget = (
  agentId: string,
  threadId: string | undefined,
  reason: string,
) =>
  uiWidget({
    agentId,
    threadId,
    widget: {
      kind: 'form',
      widgetId: `claude_code_api_key_request_${Date.now()}`,
      title: 'Anthropic API Key Required',
      description:
        `Claude Code could not authenticate (${reason}). ` +
        'Provide an Anthropic API key to continue. The key is stored as a ' +
        'workspace variable on your machine and never leaves your local runtime.',
      fields: [
        {
          id: 'apiKey',
          label: 'API Key',
          type: 'text',
          placeholder: 'sk-ant-...',
          required: true,
        },
      ],
      submitLabel: 'Save API Key',
      metadata: {
        type: 'api_key_request',
        provider: 'anthropic',
        envVar: 'ANTHROPIC_API_KEY',
        source: 'claude-code',
      },
    },
  });

const toolCallWidgetId = (toolUseId: string) => `claude_code_tool_${toolUseId}`;

const truncate = (s: string, max: number) => (s.length > max ? `${s.slice(0, max)}\n…` : s);

const formatJsonForWidget = (value: unknown, maxLen: number): string => {
  try {
    return truncate(JSON.stringify(value, null, 2), maxLen);
  } catch {
    return truncate(String(value), maxLen);
  }
};

const formatToolResultPayload = (
  content: unknown,
  isError?: boolean,
): { body: string; state?: 'error' } => {
  let body: string;
  if (typeof content === 'string') {
    body = truncate(content, 12_000);
  } else if (Array.isArray(content)) {
    const textParts: string[] = [];
    for (const block of content) {
      if (block && typeof block === 'object' && (block as { type?: string }).type === 'text') {
        const t = (block as { text?: unknown }).text;
        if (typeof t === 'string' && t.length > 0) textParts.push(t);
      }
    }
    body =
      textParts.length > 0
        ? truncate(textParts.join('\n'), 12_000)
        : formatJsonForWidget(content, 12_000);
  } else {
    body = formatJsonForWidget(content, 12_000);
  }
  return isError ? { body, state: 'error' } : { body };
};

type ParsedToolUse = { toolUseId: string; title: string; input: unknown };

const parseToolUseBlock = (block: unknown): ParsedToolUse | null => {
  if (!block || typeof block !== 'object' || !('type' in block)) return null;
  const type = (block as { type: string }).type;
  if (type === 'tool_use') {
    const b = block as { id?: unknown; name?: unknown; input?: unknown };
    if (typeof b.id !== 'string' || typeof b.name !== 'string') return null;
    return { toolUseId: b.id, title: b.name, input: b.input };
  }
  if (type === 'mcp_tool_use') {
    const b = block as { id?: unknown; name?: unknown; server_name?: unknown; input?: unknown };
    if (typeof b.id !== 'string' || typeof b.name !== 'string') return null;
    const title =
      typeof b.server_name === 'string' ? `${b.server_name}: ${b.name}` : b.name;
    return { toolUseId: b.id, title, input: b.input };
  }
  if (type === 'server_tool_use') {
    const b = block as { id?: unknown; name?: unknown; input?: unknown };
    if (typeof b.id !== 'string' || typeof b.name !== 'string') return null;
    return { toolUseId: b.id, title: b.name, input: b.input };
  }
  return null;
};

type ParsedToolResult = { toolUseId: string; content: unknown; isError?: boolean };

const parseToolResultBlock = (block: unknown): ParsedToolResult | null => {
  if (!block || typeof block !== 'object' || !('type' in block)) return null;
  const type = (block as { type: string }).type;
  if (type === 'tool_result' || type === 'mcp_tool_result') {
    const b = block as { tool_use_id?: unknown; content?: unknown; is_error?: boolean };
    if (typeof b.tool_use_id !== 'string') return null;
    return { toolUseId: b.tool_use_id, content: b.content, isError: b.is_error };
  }
  return null;
};

/**
 * OpenBot plugin that drives an agent backed by `@anthropic-ai/claude-agent-sdk`.
 */
export const claudeCodeRuntime =
  (options: ClaudeCodeRuntimeOptions = {}): PluginFactory =>
    (builder) => {
      const {
        model = 'sonnet',
        system,
        permissionMode = 'default',
        cwd,
        allowedTools,
        storage,
      } = options;

      builder.on('agent:invoke', async function* (event, context) {
        if (!shouldHandleInvoke(event as AgentInvokeEvent, context.state.agentId)) {
          return;
        }

        const userContent =
          typeof event.data?.content === 'string' ? event.data.content : '';
        if (!userContent) return;

        const threadId = event.meta?.threadId || context.state.threadId;

        const resumeId = readPersistedSessionId(context.state);
        const workingDir = cwd ?? context.state.channelDetails?.cwd;

        const sdkOptions: Options = {
          model,
          permissionMode,
          ...(system ? { systemPrompt: { type: 'preset', preset: 'claude_code', append: system } } : {}),
          ...(resumeId ? { resume: resumeId } : {}),
          ...(workingDir ? { cwd: workingDir } : {}),
          ...(allowedTools ? { allowedTools } : {}),
        };

        try {
          let lastSessionId: string | undefined = resumeId;
          let authWidgetYielded = false;
          const emittedToolCallIds = new Set<string>();
          const emittedToolResultIds = new Set<string>();
          const toolTitleByUseId = new Map<string, { title: string; input: unknown }>();

          for await (const message of query({ prompt: userContent, options: sdkOptions })) {
            if ('session_id' in message && typeof message.session_id === 'string') {
              lastSessionId = message.session_id;
            }

            if (
              !authWidgetYielded &&
              message.type === 'assistant' &&
              (message.error === 'authentication_failed' ||
                message.error === 'oauth_org_not_allowed')
            ) {
              authWidgetYielded = true;
              yield buildApiKeyWidget(context.state.agentId, threadId, message.error);
              return;
            }

            if (message.type === 'assistant') {
              const content = message.message?.content;
              if (Array.isArray(content)) {
                const textParts: string[] = [];
                for (const block of content) {
                  const tool = parseToolUseBlock(block);
                  if (tool) {
                    if (textParts.length > 0) {
                      const joined = textParts.join('\n');
                      textParts.length = 0;
                      if (joined.length > 0) {
                        yield agentOutput({
                          agentId: context.state.agentId,
                          threadId,
                          content: joined,
                        });
                      }
                    }
                    if (!emittedToolCallIds.has(tool.toolUseId)) {
                      emittedToolCallIds.add(tool.toolUseId);
                      toolTitleByUseId.set(tool.toolUseId, { title: tool.title, input: tool.input });
                      yield uiWidget({
                        agentId: context.state.agentId,
                        threadId,
                        widget: {
                          kind: 'message',
                          widgetId: toolCallWidgetId(tool.toolUseId),
                          title: toolTitleByUseId.get(tool.toolUseId)?.title ?? '',
                          description: JSON.stringify(toolTitleByUseId.get(tool.toolUseId)?.input ?? {}),
                          body: formatJsonForWidget(tool.input, 8000),
                          display: 'collapsed',
                          metadata: {
                            type: 'claude_tool',
                            phase: 'call',
                            toolName: tool.title,
                            toolUseId: tool.toolUseId,
                            source: 'claude-code',
                          },
                        },
                      });
                    }
                    continue;
                  }
                  if (block && typeof block === 'object' && (block as { type?: string }).type === 'text') {
                    const t = (block as { text?: unknown }).text;
                    if (typeof t === 'string' && t.length > 0) textParts.push(t);
                  }
                }
                if (textParts.length > 0) {
                  const joined = textParts.join('\n');
                  if (joined.length > 0) {
                    yield agentOutput({
                      agentId: context.state.agentId,
                      threadId,
                      content: joined,
                    });
                  }
                }
              }
            }

            if (message.type === 'user') {
              const param = message.message;
              if (param.role === 'user' && Array.isArray(param.content)) {
                for (const block of param.content) {
                  const res = parseToolResultBlock(block);
                  if (!res || emittedToolResultIds.has(res.toolUseId)) continue;
                  emittedToolResultIds.add(res.toolUseId);
                  const { body, state } = formatToolResultPayload(res.content, res.isError);
                  yield uiWidget({
                    agentId: context.state.agentId,
                    threadId,
                    widget: {
                      kind: 'message',
                      widgetId: toolCallWidgetId(res.toolUseId),
                      title: toolTitleByUseId.get(res.toolUseId)?.title ?? '',
                      description: JSON.stringify(toolTitleByUseId.get(res.toolUseId)?.input ?? {}),
                      body,
                      display: "collapsed",
                      ...(state ? { state } : {}),
                      metadata: {
                        type: 'claude_tool',
                        phase: 'result',
                        toolUseId: res.toolUseId,
                        source: 'claude-code',
                      },
                    },
                  });
                }
              }
            }

            if (message.type === 'result' && message.subtype !== 'success') {
              const subtype = (message as { subtype: string }).subtype;
              const resultText =
                'result' in message && typeof (message as { result?: unknown }).result === 'string'
                  ? (message as { result: string }).result
                  : '';
              if (!authWidgetYielded && (isAuthErrorMessage(subtype) || isAuthErrorMessage(resultText))) {
                authWidgetYielded = true;
                yield buildApiKeyWidget(context.state.agentId, threadId, subtype);
                return;
              }
              yield agentOutput({
                agentId: context.state.agentId,
                threadId,
                content: `[claude-code] run ended with error: ${subtype}`,
              });
            }
          }

          if (lastSessionId && lastSessionId !== resumeId) {
            await persistSessionId(context.state, storage, lastSessionId);
          }
        } catch (error) {
          const errorMessage = error instanceof Error ? error.message : String(error);
          if (isAuthErrorMessage(errorMessage)) {
            yield buildApiKeyWidget(context.state.agentId, threadId, errorMessage);
            return;
          }
          yield agentOutput({
            agentId: context.state.agentId,
            threadId,
            content: `[claude-code] error: ${errorMessage}`,
          });
        }
      });

      builder.on('client:ui:widget:response', async function* (event, context) {
        const { metadata, values, widgetId } = event.data ?? {};
        if (!metadata || metadata.type !== 'api_key_request') return;
        if (metadata.source !== 'claude-code') return;
        const apiKey = values?.apiKey;
        if (typeof apiKey !== 'string' || !apiKey) return;

        const envVar = typeof metadata.envVar === 'string' ? metadata.envVar : 'ANTHROPIC_API_KEY';

        if (!storage) {
          yield agentOutput({
            agentId: context.state.agentId,
            content: '[claude-code] no storage available; cannot persist API key.',
          });
          return;
        }

        try {
          await storage.createVariable({ key: envVar, value: apiKey, secret: true });
          process.env[envVar] = apiKey;

          yield uiWidget({
            agentId: context.state.agentId,
            widget: {
              widgetId: widgetId ?? `claude_code_api_key_saved_${Date.now()}`,
              kind: 'message',
              title: 'API Key Saved',
              body: `Saved ${envVar} as a workspace variable. You can now continue the conversation.`,
              state: 'submitted',
              actions: [{ id: 'ok', label: 'Got it', variant: 'primary' }],
            },
          });

          yield agentOutput({
            agentId: context.state.agentId,
            content:
              'Saved Anthropic API key to workspace variables. Re-send your last message to retry.',
          });
        } catch (error) {
          const errorMessage = error instanceof Error ? error.message : String(error);
          yield agentOutput({
            agentId: context.state.agentId,
            content: `[claude-code] failed to save API key: ${errorMessage}`,
          });
        }
      });
    };