@mseep/claudian 2.0.25

package/src/providers/claude/runtime/ClaudeTaskResultInterpreter.ts

@@ -0,0 +1,172 @@
+import type {
+  ProviderTaskResultInterpreter,
+  ProviderTaskTerminalStatus,
+} from '../../../core/providers/types';
+import {
+  extractAgentIdFromToolUseResult,
+  extractXmlTag,
+  resolveToolUseResultStatus,
+} from '../history/ClaudeHistoryStore';
+
+function extractAgentIdFromString(value: string): string | null {
+  const regexPatterns = [
+    /"agent_id"\s*:\s*"([^"]+)"/,
+    /"agentId"\s*:\s*"([^"]+)"/,
+    /agent_id[=:]\s*"?([a-zA-Z0-9_-]+)"?/i,
+    /agentId[=:]\s*"?([a-zA-Z0-9_-]+)"?/i,
+  ];
+
+  for (const pattern of regexPatterns) {
+    const match = value.match(pattern);
+    if (match && match[1]) {
+      return match[1];
+    }
+  }
+
+  return null;
+}
+
+function extractResultFromTaskObject(task: unknown): string | null {
+  if (!task || typeof task !== 'object') {
+    return null;
+  }
+
+  const record = task as Record<string, unknown>;
+  const result = typeof record.result === 'string' ? record.result.trim() : '';
+  if (result.length > 0) {
+    return result;
+  }
+
+  const output = typeof record.output === 'string' ? record.output.trim() : '';
+  return output.length > 0 ? output : null;
+}
+
+function extractTextFromContentBlocks(content: unknown): string | null {
+  if (!Array.isArray(content)) {
+    return null;
+  }
+
+  const firstTextBlock = (content as Array<Record<string, unknown>>)
+    .find(block => block && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string');
+  if (!firstTextBlock || typeof firstTextBlock.text !== 'string') {
+    return null;
+  }
+
+  const text = firstTextBlock.text.trim();
+  return text.length > 0 ? text : null;
+}
+
+export class ClaudeTaskResultInterpreter implements ProviderTaskResultInterpreter {
+  hasAsyncLaunchMarker(toolUseResult: unknown): boolean {
+    if (!toolUseResult || typeof toolUseResult !== 'object') {
+      return false;
+    }
+
+    const record = toolUseResult as Record<string, unknown>;
+    if (record.isAsync === true) {
+      return true;
+    }
+
+    const rawStatus = record.retrieval_status ?? record.status;
+    if (typeof rawStatus === 'string' && rawStatus.toLowerCase() === 'async_launched') {
+      return true;
+    }
+
+    // Sync Task results can still carry agentId metadata, so only treat
+    // output files as async when an explicit async marker is otherwise absent.
+    return typeof record.outputFile === 'string' && record.outputFile.length > 0;
+  }
+
+  extractAgentId(toolUseResult: unknown): string | null {
+    const directId = extractAgentIdFromToolUseResult(toolUseResult);
+    if (directId) {
+      return directId;
+    }
+
+    if (!toolUseResult || typeof toolUseResult !== 'object') {
+      return null;
+    }
+
+    const record = toolUseResult as Record<string, unknown>;
+    if (Array.isArray(record.content)) {
+      for (const block of record.content) {
+        if (typeof block === 'string') {
+          const extracted = extractAgentIdFromString(block);
+          if (extracted) {
+            return extracted;
+          }
+          continue;
+        }
+
+        if (!block || typeof block !== 'object') {
+          continue;
+        }
+
+        const text = (block as Record<string, unknown>).text;
+        if (typeof text !== 'string') {
+          continue;
+        }
+
+        const extracted = extractAgentIdFromString(text);
+        if (extracted) {
+          return extracted;
+        }
+      }
+    }
+
+    if (typeof record.content === 'string') {
+      return extractAgentIdFromString(record.content);
+    }
+
+    return null;
+  }
+
+  extractStructuredResult(toolUseResult: unknown): string | null {
+    if (!toolUseResult || typeof toolUseResult !== 'object') {
+      return null;
+    }
+
+    const record = toolUseResult as Record<string, unknown>;
+    if (record.retrieval_status === 'error') {
+      const errorMsg = typeof record.error === 'string' ? record.error : 'Task retrieval failed';
+      return `Error: ${errorMsg}`;
+    }
+
+    const taskResult = extractResultFromTaskObject(record.task);
+    if (taskResult) {
+      return taskResult;
+    }
+
+    const result = typeof record.result === 'string' ? record.result.trim() : '';
+    if (result.length > 0) {
+      return result;
+    }
+
+    const output = typeof record.output === 'string' ? record.output.trim() : '';
+    if (output.length > 0) {
+      return output;
+    }
+
+    return extractTextFromContentBlocks(record.content);
+  }
+
+  resolveTerminalStatus(
+    toolUseResult: unknown,
+    fallbackStatus: ProviderTaskTerminalStatus,
+  ): ProviderTaskTerminalStatus {
+    const resolved = resolveToolUseResultStatus(toolUseResult, fallbackStatus);
+    if (resolved === 'error') {
+      return 'error';
+    }
+
+    if (resolved === 'completed') {
+      return 'completed';
+    }
+
+    return fallbackStatus;
+  }
+
+  extractTagValue(payload: string, tagName: string): string | null {
+    return extractXmlTag(payload, tagName);
+  }
+}

package/src/providers/claude/runtime/ClaudeUserMessageFactory.ts

@@ -0,0 +1,83 @@
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+import { randomUUID } from 'crypto';
+
+import type { ImageAttachment } from '../../../core/types';
+import type { UserContentBlock } from './types';
+
+function buildUserContentBlocks(prompt: string, images?: ImageAttachment[]): UserContentBlock[] {
+  const content: UserContentBlock[] = [];
+
+  for (const image of images ?? []) {
+    content.push({
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: image.mediaType,
+        data: image.data,
+      },
+    });
+  }
+
+  if (prompt.trim()) {
+    content.push({
+      type: 'text',
+      text: prompt,
+    });
+  }
+
+  return content;
+}
+
+export function buildClaudeSDKUserMessage(
+  prompt: string,
+  sessionId: string,
+  images?: ImageAttachment[],
+): SDKUserMessage {
+  if (!images || images.length === 0) {
+    return {
+      type: 'user',
+      message: {
+        role: 'user',
+        content: prompt,
+      },
+      parent_tool_use_id: null,
+      session_id: sessionId,
+      uuid: randomUUID(),
+    };
+  }
+
+  return {
+    type: 'user',
+    message: {
+      role: 'user',
+      content: buildUserContentBlocks(prompt, images),
+    },
+    parent_tool_use_id: null,
+    session_id: sessionId,
+    uuid: randomUUID(),
+  };
+}
+
+export function buildClaudePromptWithImages(
+  prompt: string,
+  images?: ImageAttachment[],
+): string | AsyncGenerator<SDKUserMessage> {
+  if (!images || images.length === 0) {
+    return prompt;
+  }
+
+  const content = buildUserContentBlocks(prompt, images);
+
+  async function* messageGenerator() {
+    yield {
+      type: 'user' as const,
+      message: {
+        role: 'user' as const,
+        content,
+      },
+      parent_tool_use_id: null,
+    };
+  }
+
+  return messageGenerator();
+}

package/src/providers/claude/runtime/claudeColdStartQuery.ts

@@ -0,0 +1,152 @@
+import type { Options } from '@anthropic-ai/claude-agent-sdk';
+import { query as agentQuery } from '@anthropic-ai/claude-agent-sdk';
+
+import { ProviderSettingsCoordinator } from '../../../core/providers/ProviderSettingsCoordinator';
+import type ClaudianPlugin from '../../../main';
+import { getEnhancedPath, getMissingNodeError, parseEnvironmentVariables } from '../../../utils/env';
+import { getVaultPath } from '../../../utils/path';
+import { extractAssistantText } from '../auxiliary/extractAssistantText';
+import { toClaudeRuntimeModelId } from '../modelSelection';
+import {
+  getClaudeProviderSettings,
+  resolveClaudeSettingSources,
+} from '../settings';
+import {
+  resolveEffortLevel,
+} from '../types/models';
+import { createCustomSpawnFunction } from './customSpawn';
+
+export interface ColdStartQueryConfig {
+  plugin: ClaudianPlugin;
+  systemPrompt: string;
+  /** Tools available to the model. Omit for SDK default (all tools). */
+  tools?: string[];
+  hooks?: Options['hooks'];
+  /** Override model. Default: provider setting. */
+  model?: string;
+  /**
+   * Thinking configuration override:
+   * - undefined: use provider settings (adaptive or budget-based)
+   * - { disabled: true }: skip all thinking configuration
+   */
+  thinking?: { disabled: true };
+  /** Default: SDK default (true). */
+  persistSession?: boolean;
+  resumeSessionId?: string;
+  abortController?: AbortController;
+  /** Pre-fetched provider settings snapshot. Avoids a redundant fetch when the caller already has one. */
+  providerSettings?: Record<string, unknown>;
+  /** Called with accumulated text after each chunk. */
+  onTextChunk?: (accumulatedText: string) => void;
+}
+
+export interface ColdStartQueryResult {
+  text: string;
+  sessionId: string | null;
+}
+
+export async function runColdStartQuery(
+  config: ColdStartQueryConfig,
+  prompt: string,
+): Promise<ColdStartQueryResult> {
+  const vaultPath = getVaultPath(config.plugin.app);
+  if (!vaultPath) {
+    throw new Error('Could not determine vault path');
+  }
+
+  const resolvedClaudePath = config.plugin.getResolvedProviderCliPath('claude');
+  if (!resolvedClaudePath) {
+    throw new Error('Claude CLI not found');
+  }
+
+  const customEnv = parseEnvironmentVariables(
+    config.plugin.getActiveEnvironmentVariables('claude')
+  );
+  const enhancedPath = getEnhancedPath(customEnv.PATH, resolvedClaudePath);
+
+  const missingNodeError = getMissingNodeError(resolvedClaudePath, enhancedPath);
+  if (missingNodeError) {
+    throw new Error(missingNodeError);
+  }
+
+  const settings = config.providerSettings
+    ?? ProviderSettingsCoordinator.getProviderSettingsSnapshot(
+      config.plugin.settings,
+      'claude',
+    );
+  const claudeSettings = getClaudeProviderSettings(settings);
+
+  const selectedModel = toClaudeRuntimeModelId(config.model ?? (settings.model as string));
+
+  const options: Options = {
+    cwd: vaultPath,
+    systemPrompt: config.systemPrompt,
+    model: selectedModel,
+    abortController: config.abortController,
+    pathToClaudeCodeExecutable: resolvedClaudePath,
+    env: {
+      ...process.env,
+      ...customEnv,
+      PATH: enhancedPath,
+    },
+    permissionMode: 'bypassPermissions',
+    allowDangerouslySkipPermissions: true,
+    settingSources: resolveClaudeSettingSources(claudeSettings.loadUserSettings),
+    spawnClaudeCodeProcess: createCustomSpawnFunction(enhancedPath),
+  };
+
+  if (config.tools !== undefined) {
+    options.tools = config.tools;
+  }
+
+  if (config.hooks) {
+    options.hooks = config.hooks;
+  }
+
+  if (config.persistSession === false) {
+    options.persistSession = false;
+  }
+
+  if (config.resumeSessionId) {
+    options.resume = config.resumeSessionId;
+  }
+
+  if (claudeSettings.safeMode === 'auto') {
+    options.extraArgs = { ...options.extraArgs, 'enable-auto-mode': null };
+  }
+
+  if (!config.thinking?.disabled) {
+    const effortLevel = resolveEffortLevel(selectedModel, settings.effortLevel);
+    options.thinking = { type: 'adaptive' };
+    // SDK runtime accepts `xhigh` on Opus 4.7+ and silently falls back to
+    // `high` elsewhere, but its type definition lags our local EffortLevel.
+    options.effort = effortLevel;
+  }
+
+  const response = agentQuery({ prompt, options });
+  let responseText = '';
+  let sessionId: string | null = null;
+
+  for await (const message of response) {
+    if (config.abortController?.signal.aborted) {
+      await response.interrupt();
+      throw new Error('Cancelled');
+    }
+
+    if (
+      message.type === 'system' &&
+      message.subtype === 'init' &&
+      message.session_id
+    ) {
+      sessionId = message.session_id;
+    }
+
+    const text = extractAssistantText(message);
+    if (text) {
+      responseText += text;
+      config.onTextChunk?.(responseText);
+    }
+  }
+
+  return { text: responseText, sessionId };
+}

package/src/providers/claude/runtime/customSpawn.ts

@@ -0,0 +1,87 @@
+import type { SpawnedProcess, SpawnOptions } from '@anthropic-ai/claude-agent-sdk';
+import { type ChildProcess, spawn } from 'child_process';
+
+import { cliPathRequiresNode, findNodeExecutable } from '../../../utils/env';
+import {
+  resolveWindowsCmdShimSpawnSpec,
+  terminateSpawnedProcess,
+  type WindowsCmdShimSpawnSpec,
+} from '../../../utils/windowsCmdShim';
+
+export function createCustomSpawnFunction(
+  enhancedPath: string
+): (options: SpawnOptions) => SpawnedProcess {
+  return (options: SpawnOptions): SpawnedProcess => {
+    let { command } = options;
+    let { args } = options;
+    const { cwd, env, signal } = options;
+    const shouldPipeStderr = !!env?.DEBUG_CLAUDE_AGENT_SDK;
+
+    // The SDK only routes some script extensions through `node`; normalize the
+    // remaining Node-backed paths here before Electron spawns with shell=false.
+    if (command === 'node' || cliPathRequiresNode(command)) {
+      const nodeFullPath = findNodeExecutable(enhancedPath);
+      if (command === 'node') {
+        if (nodeFullPath) {
+          command = nodeFullPath;
+        }
+      } else {
+        args = [command, ...args];
+        command = nodeFullPath ?? 'node';
+      }
+    }
+
+    const resolvedSpawnSpec = resolveWindowsCmdShimSpawnSpec({ args, command });
+
+    // Do not pass `signal` directly to spawn() — Obsidian's Electron runtime
+    // uses a different realm for AbortSignal, causing `instanceof EventTarget`
+    // checks inside Node's internals to fail. Handle abort manually instead.
+    const child = spawn(resolvedSpawnSpec.command, resolvedSpawnSpec.args, {
+      cwd,
+      env: env,
+      stdio: ['pipe', 'pipe', shouldPipeStderr ? 'pipe' : 'ignore'],
+      windowsHide: true,
+      ...(resolvedSpawnSpec.windowsVerbatimArguments ? { windowsVerbatimArguments: true } : {}),
+    });
+    installTreeAwareKill(child, resolvedSpawnSpec);
+
+    if (signal) {
+      const killChild = (): void => {
+        child.kill('SIGTERM');
+      };
+      if (signal.aborted) {
+        killChild();
+      } else {
+        signal.addEventListener('abort', killChild, { once: true });
+      }
+    }
+
+    if (shouldPipeStderr && child.stderr && typeof child.stderr.on === 'function') {
+      child.stderr.on('data', () => {});
+    }
+
+    if (!child.stdin || !child.stdout) {
+      throw new Error('Failed to create process streams');
+    }
+
+    return child as unknown as SpawnedProcess;
+  };
+}
+
+function installTreeAwareKill(child: ChildProcess, spawnSpec: WindowsCmdShimSpawnSpec): void {
+  if (!spawnSpec.killProcessTree) {
+    return;
+  }
+
+  const originalKill: (signal?: NodeJS.Signals | number) => boolean = child.kill.bind(child);
+  const killableChild = {
+    get pid(): number | undefined {
+      return child.pid;
+    },
+    kill: (signal?: NodeJS.Signals | number): boolean => originalKill(signal),
+  };
+
+  child.kill = ((signal?: NodeJS.Signals | number): boolean =>
+    terminateSpawnedProcess(killableChild, signal, spawn, spawnSpec)
+  );
+}

package/src/providers/claude/runtime/types.ts

@@ -0,0 +1,134 @@
+import type {
+  PermissionMode as SDKPermissionMode,
+  SDKMessage,
+  SDKUserMessage,
+} from '@anthropic-ai/claude-agent-sdk';
+
+import type { ChatRuntimeEnsureReadyOptions } from '../../../core/runtime/types';
+import type { ImageAttachment, StreamChunk } from '../../../core/types';
+import type { PermissionMode } from '../../../core/types/settings';
+import type { ClaudeModel, EffortLevel } from '../types/models';
+
+export interface TextContentBlock {
+  type: 'text';
+  text: string;
+}
+
+export interface ImageContentBlock {
+  type: 'image';
+  source: {
+    type: 'base64';
+    media_type: ImageAttachment['mediaType'];
+    data: string;
+  };
+}
+
+export type UserContentBlock = TextContentBlock | ImageContentBlock;
+
+export const MESSAGE_CHANNEL_CONFIG = {
+  MAX_QUEUED_MESSAGES: 8, // Memory protection from rapid user input
+  MAX_MERGED_CHARS: 12000, // ~3k tokens — batch size under context limits
+} as const;
+
+export interface PendingTextMessage {
+  type: 'text';
+  content: string;
+}
+
+export interface PendingAttachmentMessage {
+  type: 'attachment';
+  message: SDKUserMessage;
+}
+
+export type PendingMessage = PendingTextMessage | PendingAttachmentMessage;
+
+export interface ClosePersistentQueryOptions {
+  preserveHandlers?: boolean;
+}
+
+export interface ClaudeEnsureReadyOptions extends ChatRuntimeEnsureReadyOptions {
+  externalContextPaths?: string[];
+  preserveHandlers?: boolean;
+  sessionId?: string;
+}
+
+export interface ResponseHandler {
+  readonly id: string;
+  onChunk: (chunk: StreamChunk) => void;
+  onDone: () => void;
+  onError: (error: Error) => void;
+  readonly sawStreamText: boolean;
+  readonly sawStreamThinking: boolean;
+  readonly sawAnyChunk: boolean;
+  markStreamTextSeen(): void;
+  markStreamThinkingSeen(): void;
+  resetStreamText(): void;
+  resetStreamThinking(): void;
+  markChunkSeen(): void;
+}
+
+export interface ResponseHandlerOptions {
+  id: string;
+  onChunk: (chunk: StreamChunk) => void;
+  onDone: () => void;
+  onError: (error: Error) => void;
+}
+
+export function createResponseHandler(options: ResponseHandlerOptions): ResponseHandler {
+  let _sawStreamText = false;
+  let _sawStreamThinking = false;
+  let _sawAnyChunk = false;
+
+  return {
+    id: options.id,
+    onChunk: options.onChunk,
+    onDone: options.onDone,
+    onError: options.onError,
+    get sawStreamText() { return _sawStreamText; },
+    get sawStreamThinking() { return _sawStreamThinking; },
+    get sawAnyChunk() { return _sawAnyChunk; },
+    markStreamTextSeen() { _sawStreamText = true; },
+    markStreamThinkingSeen() { _sawStreamThinking = true; },
+    resetStreamText() { _sawStreamText = false; },
+    resetStreamThinking() { _sawStreamThinking = false; },
+    markChunkSeen() { _sawAnyChunk = true; },
+  };
+}
+
+export interface PersistentQueryConfig {
+  model: string | null;
+  effortLevel: EffortLevel;
+  permissionMode: PermissionMode | null;
+  sdkPermissionMode: SDKPermissionMode | null;
+  systemPromptKey: string;
+  disallowedToolsKey: string;
+  mcpServersKey: string;
+  pluginsKey: string;
+  externalContextPaths: string[];
+  settingSources: string;
+  claudeCliPath: string;
+  enableChrome: boolean;
+  enableAutoMode: boolean;
+}
+
+export interface SessionState {
+  sessionId: string | null;
+  sessionModel: ClaudeModel | null;
+  pendingSessionModel: ClaudeModel | null;
+  wasInterrupted: boolean;
+  /** Set when SDK returns a different session ID than expected (context lost). */
+  needsHistoryRebuild: boolean;
+  /** Set when the current session is invalidated by SDK errors. */
+  sessionInvalidated: boolean;
+}
+
+export const UNSUPPORTED_SDK_TOOLS = [] as const;
+
+/** Built-in subagents that don't apply to Obsidian context. */
+export const DISABLED_BUILTIN_SUBAGENTS = [
+  'Task(statusline-setup)',
+] as const;
+
+export function isTurnCompleteMessage(message: SDKMessage): boolean {
+  return message.type === 'result';
+}

package/src/providers/claude/sdk/messages.ts

@@ -0,0 +1,17 @@
+import type { SDKUserMessage } from '@anthropic-ai/claude-agent-sdk';
+
+export type { SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+
+export type BlockedUserMessage = SDKUserMessage & {
+  _blocked: true;
+  _blockReason: string;
+};
+
+export function isBlockedMessage(message: { type: string }): message is BlockedUserMessage {
+  return (
+    message.type === 'user' &&
+    '_blocked' in message &&
+    (message as Record<string, unknown>)._blocked === true &&
+    '_blockReason' in message
+  );
+}

package/src/providers/claude/sdk/toolResultContent.ts

@@ -0,0 +1,4 @@
+export {
+  extractToolResultContent,
+  type ToolResultContentOptions,
+} from '../../../core/tools/toolResultContent';

package/src/providers/claude/sdk/typeGuards.ts

@@ -0,0 +1,14 @@
+import type { StreamChunk } from '../../../core/types';
+import type { ContextWindowEvent, SessionInitEvent, TransformEvent } from './types';
+
+export function isSessionInitEvent(event: TransformEvent): event is SessionInitEvent {
+  return event.type === 'session_init';
+}
+
+export function isContextWindowEvent(event: TransformEvent): event is ContextWindowEvent {
+  return event.type === 'context_window';
+}
+
+export function isStreamChunk(event: TransformEvent): event is StreamChunk {
+  return event.type !== 'session_init' && event.type !== 'context_window';
+}

package/src/providers/claude/sdk/types.ts

@@ -0,0 +1,15 @@
+import type { StreamChunk } from '../../../core/types';
+
+export interface SessionInitEvent {
+  type: 'session_init';
+  sessionId: string;
+  agents?: string[];
+  permissionMode?: string;
+}
+
+export interface ContextWindowEvent {
+  type: 'context_window';
+  contextWindow: number;
+}
+
+export type TransformEvent = StreamChunk | SessionInitEvent | ContextWindowEvent;