@mseep/claudian 2.0.25

package/src/providers/pi/models.ts

@@ -0,0 +1,302 @@
+export type PiThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+
+export interface PiDiscoveredModel {
+  api?: string;
+  contextWindow?: number;
+  encodedId: string;
+  id: string;
+  input: Array<'text' | 'image'>;
+  label: string;
+  maxTokens?: number;
+  provider: string;
+  reasoning: boolean;
+  thinkingLevels: PiThinkingLevel[];
+}
+
+export interface DecodedPiModelId {
+  modelId: string;
+  provider: string;
+}
+
+export const PI_SYNTHETIC_MODEL_ID = 'pi';
+export const PI_MODEL_PREFIX = 'pi:';
+export const PI_DEFAULT_THINKING_LEVEL: PiThinkingLevel = 'medium';
+
+const VALID_THINKING_LEVELS = new Set<PiThinkingLevel>([
+  'off',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+]);
+
+const DEFAULT_REASONING_LEVELS: PiThinkingLevel[] = [
+  'off',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+];
+
+export function isPiModelSelectionId(model: string): boolean {
+  return model === PI_SYNTHETIC_MODEL_ID || model.startsWith(PI_MODEL_PREFIX);
+}
+
+export function encodePiModelId(provider: string, modelId: string): string {
+  const normalizedProvider = provider.trim();
+  const normalizedModelId = modelId.trim();
+  if (!normalizedProvider || !normalizedModelId) {
+    return PI_SYNTHETIC_MODEL_ID;
+  }
+
+  return `${PI_MODEL_PREFIX}${normalizedProvider}/${normalizedModelId}`;
+}
+
+export function decodePiModelId(model: string): DecodedPiModelId | null {
+  if (!model.startsWith(PI_MODEL_PREFIX)) {
+    return null;
+  }
+
+  const raw = model.slice(PI_MODEL_PREFIX.length).trim();
+  const slashIndex = raw.indexOf('/');
+  if (slashIndex <= 0 || slashIndex >= raw.length - 1) {
+    return null;
+  }
+
+  const provider = raw.slice(0, slashIndex).trim();
+  const modelId = raw.slice(slashIndex + 1).trim();
+  return provider && modelId ? { provider, modelId } : null;
+}
+
+export function normalizePiThinkingLevel(value: unknown): PiThinkingLevel | null {
+  if (typeof value !== 'string') {
+    return null;
+  }
+
+  const normalized = value.trim().toLowerCase();
+  return VALID_THINKING_LEVELS.has(normalized as PiThinkingLevel)
+    ? normalized as PiThinkingLevel
+    : null;
+}
+
+export function getPiSupportedThinkingLevels(value: unknown): PiThinkingLevel[] {
+  const record = isPlainObject(value) ? value : {};
+  const explicitLevels = collectExplicitThinkingLevels(record);
+  const mappedLevels = collectThinkingLevelMapLevels(record);
+  const reasoning = record.reasoning === true
+    || record.supportsReasoning === true
+    || record.thinking === true
+    || record.canReason === true
+    || explicitLevels.length > 0
+    || mappedLevels.levels.length > 0;
+  if (!reasoning) {
+    return ['off'];
+  }
+
+  if (explicitLevels.length === 0 && mappedLevels.levels.length === 0) {
+    return [...DEFAULT_REASONING_LEVELS];
+  }
+
+  const result: PiThinkingLevel[] = [];
+  const seen = new Set<PiThinkingLevel>();
+  for (const level of [...explicitLevels, ...mappedLevels.levels]) {
+    if (level === null || mappedLevels.disabledLevels.has(level)) {
+      continue;
+    }
+
+    if (!seen.has(level)) {
+      seen.add(level);
+      result.push(level);
+    }
+  }
+
+  return result.length > 0 ? sortThinkingLevels(result) : [...DEFAULT_REASONING_LEVELS];
+}
+
+export function normalizePiDiscoveredModels(value: unknown): PiDiscoveredModel[] {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+
+  const normalized: PiDiscoveredModel[] = [];
+  const seen = new Set<string>();
+  for (const entry of value) {
+    if (!isPlainObject(entry)) {
+      continue;
+    }
+
+    const provider = firstString(entry.provider, entry.providerId, entry.api)?.trim() ?? '';
+    const id = firstString(entry.id, entry.modelId, entry.model, entry.name)?.trim() ?? '';
+    if (!provider || !id) {
+      continue;
+    }
+
+    const key = `${provider}\0${id}`;
+    if (seen.has(key)) {
+      continue;
+    }
+
+    seen.add(key);
+    const label = firstString(entry.label, entry.displayName, entry.name)?.trim()
+      || `${provider}/${id}`;
+    const api = firstString(entry.api)?.trim();
+    const contextWindow = firstFinitePositiveNumber(
+      entry.contextWindow,
+      entry.context_window,
+      entry.context,
+      entry.maxContextTokens,
+      entry.max_context_tokens,
+    );
+    const maxTokens = firstFinitePositiveNumber(
+      entry.maxTokens,
+      entry.max_tokens,
+      entry.outputTokens,
+      entry.output_tokens,
+    );
+    const input = normalizeModelInputs(
+      entry.input ?? entry.inputs ?? entry.modalities ?? entry.supportedInputs,
+    );
+    const thinkingLevels = getPiSupportedThinkingLevels(entry);
+    const reasoning = thinkingLevels.some(level => level !== 'off');
+
+    normalized.push({
+      ...(api ? { api } : {}),
+      ...(contextWindow !== undefined ? { contextWindow } : {}),
+      encodedId: encodePiModelId(provider, id),
+      id,
+      input,
+      label,
+      ...(maxTokens !== undefined ? { maxTokens } : {}),
+      provider,
+      reasoning,
+      thinkingLevels,
+    });
+  }
+
+  return normalized;
+}
+
+export function findPiModel(
+  settings: { discoveredModels: PiDiscoveredModel[] },
+  encodedId: string,
+): PiDiscoveredModel | null {
+  return settings.discoveredModels.find(model => model.encodedId === encodedId) ?? null;
+}
+
+export function clampPiThinkingLevel(
+  level: string | undefined,
+  supportedLevels: PiThinkingLevel[],
+): PiThinkingLevel {
+  const normalized = normalizePiThinkingLevel(level);
+  if (normalized && supportedLevels.includes(normalized)) {
+    return normalized;
+  }
+
+  if (supportedLevels.includes(PI_DEFAULT_THINKING_LEVEL)) {
+    return PI_DEFAULT_THINKING_LEVEL;
+  }
+
+  return supportedLevels[0] ?? 'off';
+}
+
+function collectExplicitThinkingLevels(record: Record<string, unknown>): Array<PiThinkingLevel | null> {
+  const rawLevels = [
+    record.thinkingLevels,
+    record.thinking_levels,
+    record.reasoningLevels,
+    record.reasoning_levels,
+    isPlainObject(record.thinking) ? record.thinking.levels : undefined,
+    isPlainObject(record.reasoning) ? record.reasoning.levels : undefined,
+  ].find(Array.isArray);
+
+  if (!Array.isArray(rawLevels)) {
+    return [];
+  }
+
+  return rawLevels
+    .map((level): PiThinkingLevel | null | undefined => {
+      if (level === null) {
+        return null;
+      }
+      return normalizePiThinkingLevel(level) ?? undefined;
+    })
+    .filter((level): level is PiThinkingLevel | null => level !== undefined);
+}
+
+function collectThinkingLevelMapLevels(record: Record<string, unknown>): {
+  disabledLevels: Set<PiThinkingLevel>;
+  levels: PiThinkingLevel[];
+} {
+  const rawMap = isPlainObject(record.thinkingLevelMap)
+    ? record.thinkingLevelMap
+    : isPlainObject(record.thinking_level_map)
+    ? record.thinking_level_map
+    : null;
+  if (!rawMap) {
+    return { disabledLevels: new Set<PiThinkingLevel>(), levels: [] };
+  }
+
+  const disabledLevels = new Set<PiThinkingLevel>();
+  const levels: PiThinkingLevel[] = [...DEFAULT_REASONING_LEVELS];
+  for (const [rawLevel, mappedLevel] of Object.entries(rawMap)) {
+    const level = normalizePiThinkingLevel(rawLevel);
+    if (!level) {
+      continue;
+    }
+    if (mappedLevel === null) {
+      disabledLevels.add(level);
+    } else {
+      levels.push(level);
+    }
+  }
+  return { disabledLevels, levels };
+}
+
+function sortThinkingLevels(levels: PiThinkingLevel[]): PiThinkingLevel[] {
+  const rank = new Map(DEFAULT_REASONING_LEVELS.concat('xhigh').map((level, index) => [level, index] as const));
+  return [...levels].sort((left, right) => (rank.get(left) ?? 99) - (rank.get(right) ?? 99));
+}
+
+function normalizeModelInputs(value: unknown): Array<'text' | 'image'> {
+  const rawInputs = Array.isArray(value) ? value : ['text'];
+  const inputs: Array<'text' | 'image'> = [];
+  const seen = new Set<'text' | 'image'>();
+
+  for (const entry of rawInputs) {
+    const normalized = typeof entry === 'string' ? entry.trim().toLowerCase() : '';
+    const input = normalized === 'image' || normalized === 'images'
+      ? 'image'
+      : normalized === 'text'
+      ? 'text'
+      : null;
+    if (input && !seen.has(input)) {
+      seen.add(input);
+      inputs.push(input);
+    }
+  }
+
+  return inputs.length > 0 ? inputs : ['text'];
+}
+
+function firstString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === 'string') {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function firstFinitePositiveNumber(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    if (typeof value === 'number' && Number.isFinite(value) && value > 0) {
+      return value;
+    }
+  }
+  return undefined;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/src/providers/pi/normalizations/piEventNormalization.ts

@@ -0,0 +1,211 @@
+import type { StreamChunk } from '../../../core/types';
+import {
+  extractPiToolTextContent,
+  getPiToolId,
+  getPiToolName,
+  normalizePiToolInput,
+} from './piToolNormalization';
+
+export interface PiEventNormalizationState {
+  emittedToolIds: Set<string>;
+  toolOutputs: Map<string, string>;
+}
+
+export function createPiEventNormalizationState(): PiEventNormalizationState {
+  return {
+    emittedToolIds: new Set<string>(),
+    toolOutputs: new Map<string, string>(),
+  };
+}
+
+export function normalizePiRpcEvent(
+  event: Record<string, unknown>,
+  state: PiEventNormalizationState,
+): StreamChunk[] {
+  switch (event.type) {
+    case 'agent_start':
+      return [];
+    case 'message_update':
+      return normalizeMessageUpdate(event);
+    case 'toolcall_end':
+      return normalizeToolUse(getNestedRecord(event, 'toolCall') ?? event, state);
+    case 'tool_execution_start':
+      return normalizeToolUse(getNestedRecord(event, 'toolCall') ?? event, state);
+    case 'tool_execution_update':
+      return normalizeToolOutput(event, state);
+    case 'tool_execution_end':
+      return normalizeToolResult(event, state);
+    case 'message_end':
+    case 'turn_end':
+      return normalizeTerminalError(event);
+    case 'compaction_end':
+      return [{ type: 'context_compacted' }];
+    case 'auto_retry_start':
+      return [{ type: 'notice', content: 'Pi is retrying the turn.', level: 'warning' }];
+    case 'auto_retry_end':
+      return [{ type: 'notice', content: 'Pi retry finished.', level: 'info' }];
+    case 'extension_error':
+      return [{ type: 'notice', content: getString(event.error) ?? 'Pi extension error.', level: 'warning' }];
+    default:
+      return [];
+  }
+}
+
+export function getPiTerminalErrorMessage(event: Record<string, unknown>): string | null {
+  if (event.type !== 'message_end' && event.type !== 'turn_end') {
+    return null;
+  }
+
+  const terminalEvent = getNestedRecord(event, 'assistantMessageEvent')
+    ?? getNestedRecord(event, 'assistant_message_event')
+    ?? event;
+  const records = terminalEvent === event ? [event] : [terminalEvent, event];
+  const stopReason = getStringField(records, ['stopReason', 'stop_reason']);
+  if (stopReason?.toLowerCase() !== 'error') {
+    return null;
+  }
+
+  return getStringField(records, ['errorMessage', 'error_message', 'error', 'message'])
+    ?? getNestedStringField(records, 'error', ['message'])
+    ?? 'Pi turn failed.';
+}
+
+function normalizeMessageUpdate(event: Record<string, unknown>): StreamChunk[] {
+  const assistantEvent = getNestedRecord(event, 'assistantMessageEvent')
+    ?? getNestedRecord(event, 'assistant_message_event')
+    ?? event;
+  const textDelta = getString(assistantEvent.text_delta)
+    ?? getString(assistantEvent.textDelta)
+    ?? (
+      assistantEvent.type === 'text_delta'
+        ? getString(assistantEvent.delta)
+        : null
+    );
+  if (textDelta) {
+    return [{ type: 'text', content: textDelta }];
+  }
+
+  const thinkingDelta = getString(assistantEvent.thinking_delta)
+    ?? getString(assistantEvent.thinkingDelta)
+    ?? (
+      assistantEvent.type === 'thinking_delta'
+        ? getString(assistantEvent.delta)
+        : null
+    );
+  if (thinkingDelta) {
+    return [{ type: 'thinking', content: thinkingDelta }];
+  }
+
+  return [];
+}
+
+function normalizeTerminalError(event: Record<string, unknown>): StreamChunk[] {
+  const message = getPiTerminalErrorMessage(event);
+  return message ? [{ type: 'error', content: message }] : [];
+}
+
+function normalizeToolUse(
+  event: Record<string, unknown>,
+  state: PiEventNormalizationState,
+): StreamChunk[] {
+  const id = getPiToolId(event);
+  if (!id || state.emittedToolIds.has(id)) {
+    return [];
+  }
+
+  state.emittedToolIds.add(id);
+  const name = getPiToolName(event);
+  return [{
+    type: 'tool_use',
+    id,
+    input: normalizePiToolInput(event.input ?? event.arguments ?? event.args, name),
+    name,
+  }];
+}
+
+function normalizeToolOutput(
+  event: Record<string, unknown>,
+  state: PiEventNormalizationState,
+): StreamChunk[] {
+  const id = getPiToolId(event);
+  if (!id) {
+    return [];
+  }
+
+  const content = extractPiToolTextContent(event.partialResult ?? event.output ?? event.result ?? event.content);
+  if (!content) {
+    return [];
+  }
+
+  state.toolOutputs.set(id, content);
+  return [{ type: 'tool_output', id, content }];
+}
+
+function normalizeToolResult(
+  event: Record<string, unknown>,
+  state: PiEventNormalizationState,
+): StreamChunk[] {
+  const id = getPiToolId(event);
+  if (!id) {
+    return [];
+  }
+
+  const content = extractPiToolTextContent(event.result ?? event.output ?? event.content)
+    || state.toolOutputs.get(id)
+    || '';
+  const toolUseResult = getNestedRecord(event, 'result');
+  return [{
+    type: 'tool_result',
+    content,
+    id,
+    isError: event.isError === true || event.error === true || event.success === false,
+    ...(toolUseResult ? { toolUseResult } : {}),
+  }];
+}
+
+function getNestedRecord(
+  event: Record<string, unknown>,
+  key: string,
+): Record<string, unknown> | null {
+  const value = event[key];
+  return value !== null && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : null;
+}
+
+function getString(value: unknown): string | null {
+  return typeof value === 'string' ? value : null;
+}
+
+function getStringField(
+  records: Array<Record<string, unknown>>,
+  keys: string[],
+): string | null {
+  for (const record of records) {
+    for (const key of keys) {
+      const value = getString(record[key]);
+      if (value) {
+        return value;
+      }
+    }
+  }
+  return null;
+}
+
+function getNestedStringField(
+  records: Array<Record<string, unknown>>,
+  parentKey: string,
+  keys: string[],
+): string | null {
+  for (const record of records) {
+    const nested = getNestedRecord(record, parentKey);
+    if (!nested) {
+      continue;
+    }
+    const value = getStringField([nested], keys);
+    if (value) {
+      return value;
+    }
+  }
+  return null;
+}

package/src/providers/pi/normalizations/piToolNormalization.ts

@@ -0,0 +1,97 @@
+import {
+  TOOL_BASH,
+  TOOL_EDIT,
+  TOOL_GLOB,
+  TOOL_GREP,
+  TOOL_LS,
+  TOOL_READ,
+  TOOL_WRITE,
+} from '../../../core/tools/toolNames';
+
+const PI_BUILT_IN_TOOL_NAMES: Record<string, string> = {
+  bash: TOOL_BASH,
+  edit: TOOL_EDIT,
+  find: TOOL_GLOB,
+  grep: TOOL_GREP,
+  ls: TOOL_LS,
+  read: TOOL_READ,
+  write: TOOL_WRITE,
+};
+
+export function extractPiToolTextContent(value: unknown): string {
+  if (typeof value === 'string') {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value
+      .map(extractPiToolTextContent)
+      .filter(Boolean)
+      .join('\n');
+  }
+
+  if (!isPlainObject(value)) {
+    return '';
+  }
+
+  if (typeof value.text === 'string') {
+    return value.text;
+  }
+  if (typeof value.content === 'string') {
+    return value.content;
+  }
+  if (Array.isArray(value.content)) {
+    return extractPiToolTextContent(value.content);
+  }
+  if (isPlainObject(value.partialResult)) {
+    return extractPiToolTextContent(value.partialResult.content);
+  }
+  if (isPlainObject(value.result)) {
+    return extractPiToolTextContent(value.result.content ?? value.result);
+  }
+
+  return '';
+}
+
+export function normalizePiToolInput(value: unknown, toolName?: string): Record<string, unknown> {
+  const input = isPlainObject(value) ? { ...value } : {};
+  const normalizedToolName = toolName ? normalizePiToolName(toolName) : '';
+
+  if (
+    (normalizedToolName === TOOL_READ || normalizedToolName === TOOL_WRITE || normalizedToolName === TOOL_EDIT)
+    && typeof input.path === 'string'
+    && typeof input.file_path !== 'string'
+  ) {
+    input.file_path = input.path;
+  }
+
+  return input;
+}
+
+export function getPiToolId(value: Record<string, unknown>): string {
+  return firstString(value.id, value.toolCallId, value.callId, value.call_id) ?? '';
+}
+
+export function getPiToolName(value: Record<string, unknown>): string {
+  return normalizePiToolName(firstString(value.name, value.tool, value.toolName, value.tool_name) ?? 'tool');
+}
+
+export function normalizePiToolName(name: string): string {
+  return PI_BUILT_IN_TOOL_NAMES[name.trim().toLowerCase()] ?? name;
+}
+
+function firstString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === 'string') {
+      const trimmed = value.trim();
+      if (trimmed) {
+        return trimmed;
+      }
+    }
+  }
+  return undefined;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}

package/src/providers/pi/registration.ts

@@ -0,0 +1,30 @@
+import type { ProviderRegistration } from '../../core/providers/types';
+import { PiInlineEditService } from './auxiliary/PiInlineEditService';
+import { PiInstructionRefineService } from './auxiliary/PiInstructionRefineService';
+import { PiTaskResultInterpreter } from './auxiliary/PiTaskResultInterpreter';
+import { PiTitleGenerationService } from './auxiliary/PiTitleGenerationService';
+import { PI_PROVIDER_CAPABILITIES } from './capabilities';
+import { piSettingsReconciler } from './env/PiSettingsReconciler';
+import { PiConversationHistoryService } from './history/PiConversationHistoryService';
+import { PiChatRuntime } from './runtime/PiChatRuntime';
+import { getPiProviderSettings } from './settings';
+import { ObsidianPiExtensionUiRenderer } from './ui/ObsidianPiExtensionUiRenderer';
+import { piChatUIConfig } from './ui/PiChatUIConfig';
+
+export const piProviderRegistration: ProviderRegistration = {
+  blankTabOrder: 11,
+  capabilities: PI_PROVIDER_CAPABILITIES,
+  chatUIConfig: piChatUIConfig,
+  createInlineEditService: (plugin) => new PiInlineEditService(plugin),
+  createInstructionRefineService: (plugin) => new PiInstructionRefineService(plugin),
+  createRuntime: ({ plugin }) => new PiChatRuntime(plugin, {
+    extensionUiRenderer: new ObsidianPiExtensionUiRenderer(plugin.app),
+  }),
+  createTitleGenerationService: (plugin) => new PiTitleGenerationService(plugin),
+  displayName: 'Pi',
+  environmentKeyPatterns: [/^PI_/i],
+  historyService: new PiConversationHistoryService(),
+  isEnabled: (settings) => getPiProviderSettings(settings).enabled,
+  settingsReconciler: piSettingsReconciler,
+  taskResultInterpreter: new PiTaskResultInterpreter(),
+};