@pellux/goodvibes-tui 0.18.11 → 0.18.13

package/src/providers/tier-prompts.ts

@@ -1,84 +0,0 @@
-/**
- * Tier-based system prompt supplements.
- *
- * Model capability tiers drive how much extra guidance is injected into
- * the system prompt.  All features remain available regardless of tier;
- * only the verbosity of the guidance changes.
- */
-
-import type { ModelTier } from '@pellux/goodvibes-sdk/platform/providers/registry';
-export type { ModelTier };
-
-/**
- * Derive the model tier from a model's context window size.
- *
- * - small  (<32K)     → 'free'     (needs most guidance)
- * - medium (32K–128K) → 'standard' (brief reminders)
- * - large  (>128K)    → 'premium'  (no extra guidance needed)
- *
- * This is used instead of the static ModelDefinition.tier field so that
- * tier-prompt selection is driven by actual model capabilities.
- */
-export function getTierForContextWindow(contextWindow: number): ModelTier {
-  if (contextWindow > 128_000) return 'premium';
-  if (contextWindow >= 32_000) return 'standard';
-  return 'free';
-}
-
-/**
- * Returns supplemental system prompt content based on the model's capability
- * tier.  The returned string is appended to the base system prompt before
- * each LLM call.
- *
- * - free    — explicit tool-call examples, multi-agent reminders, structured
- *             output enforcement (~300 tokens)
- * - standard — brief reminders about tool usage and plan adherence (~80 tokens)
- * - premium  — empty; capable models need no extra hand-holding
- */
-export function getTierPromptSupplement(tier: ModelTier): string {
-  switch (tier) {
-    case 'free':
-      return FREE_SUPPLEMENT;
-    case 'standard':
-      return STANDARD_SUPPLEMENT;
-    case 'premium':
-      return '';
-    case 'subscription':
-      return '';
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Supplement text
-// ---------------------------------------------------------------------------
-
-const FREE_SUPPLEMENT = `## Agent Guidance
-
-You are operating in a multi-agent system. Follow these rules carefully:
-
-**Tool calls — required format:**
-Every tool call must include ALL required parameters. Missing parameters cause
-silent failures. When in doubt, check the tool's schema before calling it.
-
-Example — correct agent spawn:
-\`\`\`json
-{ "name": "agent", "input": { "task": "<task>", "mode": "engineer" } }
-\`\`\`
-
-**Multi-agent workflows:**
-When a plan requires multiple parallel agents, spawn ALL of them before
-waiting for results — do not spawn one, wait, then spawn the next. Parallel
-spawns run concurrently and complete faster.
-
-**Structured output:**
-Your final message MUST end with the required JSON completion block. Omitting
-it causes the orchestrator to treat your run as failed.
-
-**Plan adherence:**
-Complete the full plan. Do not stop after the first step and ask for
-confirmation — there is no human watching. Make the best choice and continue.`;
-
-const STANDARD_SUPPLEMENT = `## Reminders
-- Include all required parameters in every tool call.
-- When spawning agents, use the correct \`mode\` parameter.
-- Complete your full plan before reporting results.`;

package/src/providers/tool-formats.ts

@@ -1,414 +0,0 @@
-import type { ToolDefinition, ToolCall } from '@pellux/goodvibes-sdk/platform/types/tools';
-import type { ProviderMessage, ContentPart } from '@pellux/goodvibes-sdk/platform/providers/interface';
-import { logger } from '@pellux/goodvibes-sdk/platform/utils/logger';
-import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils/error-display';
-
-// ---------------------------------------------------------------------------
-// OpenAI wire format
-// ---------------------------------------------------------------------------
-
-export interface OpenAITool {
-  type: 'function';
-  function: {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-  };
-}
-
-export interface OpenAIToolCall {
-  id: string;
-  type: 'function';
-  function: { name: string; arguments: string };
-}
-
-export type OpenAIContentPart =
-  | { type: 'text'; text: string }
-  | { type: 'image_url'; image_url: { url: string } };
-
-export interface OpenAIMessage {
-  role: 'system' | 'user' | 'assistant' | 'tool';
-  content: string | OpenAIContentPart[] | null;
-  tool_calls?: OpenAIToolCall[];
-  tool_call_id?: string;
-}
-
-/** Convert internal ToolDefinitions to OpenAI tools array. */
-export function toOpenAITools(tools: ToolDefinition[]): OpenAITool[] {
-  return tools.map((t) => ({
-    type: 'function',
-    function: {
-      name: t.name,
-      description: t.description,
-      parameters: t.parameters,
-    },
-  }));
-}
-
-/** Parse OpenAI tool_calls from a response into internal ToolCall[]. */
-export function fromOpenAIToolCalls(calls: OpenAIToolCall[]): ToolCall[] {
-  return calls.map((c) => ({
-    id: c.id,
-    name: c.function.name,
-    arguments: parseJson(c.function.arguments),
-  }));
-}
-
-/** Convert internal ProviderMessages to OpenAI message array. */
-export function toOpenAIMessages(
-  messages: ProviderMessage[],
-  systemPrompt?: string,
-): OpenAIMessage[] {
-  const result: OpenAIMessage[] = [];
-
-  if (systemPrompt) {
-    result.push({ role: 'system', content: systemPrompt });
-  }
-
-  for (const msg of messages) {
-    if (msg.role === 'user') {
-      if (Array.isArray(msg.content)) {
-        // ContentPart[] — convert to OpenAI multimodal parts
-        const parts: OpenAIContentPart[] = msg.content.map((part: ContentPart) => {
-          if (part.type === 'text') return { type: 'text', text: part.text };
-          return { type: 'image_url', image_url: { url: `data:${part.mediaType};base64,${part.data}` } };
-        });
-        result.push({ role: 'user', content: parts });
-      } else {
-        result.push({ role: 'user', content: msg.content });
-      }
-    } else if (msg.role === 'assistant') {
-      const m: OpenAIMessage = { role: 'assistant', content: msg.content ?? '' };
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        m.tool_calls = msg.toolCalls.map((tc) => ({
-          id: tc.id,
-          type: 'function',
-          function: { name: tc.name, arguments: JSON.stringify(tc.arguments) },
-        }));
-      }
-      result.push(m);
-    } else if (msg.role === 'tool') {
-      result.push({
-        role: 'tool',
-        content: msg.content,
-        tool_call_id: msg.callId,
-      });
-    }
-  }
-
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Anthropic wire format
-// ---------------------------------------------------------------------------
-
-export interface AnthropicTool {
-  name: string;
-  description: string;
-  input_schema: Record<string, unknown>;
-}
-
-export type AnthropicContentBlock =
-  | { type: 'text'; text: string }
-  | { type: 'image'; source: { type: 'base64'; media_type: 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp'; data: string } }
-  | { type: 'tool_use'; id: string; name: string; input: Record<string, unknown> }
-  | { type: 'tool_result'; tool_use_id: string; content: string };
-
-export interface AnthropicMessage {
-  role: 'user' | 'assistant';
-  content: string | AnthropicContentBlock[];
-}
-
-/** Convert internal ToolDefinitions to Anthropic tools array. */
-export function toAnthropicTools(tools: ToolDefinition[]): AnthropicTool[] {
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    input_schema: t.parameters,
-  }));
-}
-
-/** Parse Anthropic response content blocks into text + ToolCall[]. */
-export function fromAnthropicContent(content: AnthropicContentBlock[]): {
-  text: string;
-  toolCalls: ToolCall[];
-} {
-  let text = '';
-  const toolCalls: ToolCall[] = [];
-
-  for (const block of content) {
-    if (block.type === 'text') {
-      text += block.text;
-    } else if (block.type === 'tool_use') {
-      toolCalls.push({ id: block.id, name: block.name, arguments: block.input });
-    }
-  }
-
-  return { text, toolCalls };
-}
-
-/** Convert internal ProviderMessages to Anthropic message array. */
-export function toAnthropicMessages(messages: ProviderMessage[]): AnthropicMessage[] {
-  const result: AnthropicMessage[] = [];
-
-  // Collect consecutive tool results to merge into one user message
-  let pendingToolResults: AnthropicContentBlock[] = [];
-
-  function flushToolResults(): void {
-    if (pendingToolResults.length > 0) {
-      result.push({ role: 'user', content: pendingToolResults });
-      pendingToolResults = [];
-    }
-  }
-
-  for (const msg of messages) {
-    if (msg.role === 'user') {
-      flushToolResults();
-      if (Array.isArray(msg.content)) {
-        // ContentPart[] — convert to Anthropic content blocks
-        const blocks: AnthropicContentBlock[] = msg.content.map((part: ContentPart) => {
-          if (part.type === 'text') return { type: 'text' as const, text: part.text };
-          return {
-            type: 'image' as const,
-            source: { type: 'base64' as const, media_type: part.mediaType as 'image/png' | 'image/jpeg' | 'image/gif' | 'image/webp', data: part.data },
-          };
-        });
-        result.push({ role: 'user', content: blocks });
-      } else {
-        result.push({ role: 'user', content: msg.content });
-      }
-    } else if (msg.role === 'assistant') {
-      flushToolResults();
-      if (msg.toolCalls && msg.toolCalls.length > 0) {
-        const blocks: AnthropicContentBlock[] = [];
-        if (msg.content) blocks.push({ type: 'text', text: msg.content });
-        for (const tc of msg.toolCalls) {
-          blocks.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.arguments });
-        }
-        result.push({ role: 'assistant', content: blocks });
-      } else {
-        result.push({ role: 'assistant', content: msg.content });
-      }
-    } else if (msg.role === 'tool') {
-      pendingToolResults.push({
-        type: 'tool_result',
-        tool_use_id: msg.callId,
-        content: msg.content,
-      });
-    }
-  }
-
-  flushToolResults();
-  return result;
-}
-
-// ---------------------------------------------------------------------------
-// Gemini wire format
-// ---------------------------------------------------------------------------
-
-export interface GeminiFunctionDeclaration {
-  name: string;
-  description: string;
-  parameters: Record<string, unknown>;
-}
-
-export interface GeminiPart {
-  text?: string;
-  inlineData?: { mimeType: string; data: string };
-  functionCall?: { name: string; args: Record<string, unknown> };
-  functionResponse?: { name: string; response: { content: string } };
-}
-
-export interface GeminiContent {
-  role: 'user' | 'model';
-  parts: GeminiPart[];
-}
-
-/** Strip properties that Gemini's API doesn't support (e.g. additionalProperties). */
-function stripUnsupportedProperties(obj: unknown): unknown {
-  if (Array.isArray(obj)) return obj.map(stripUnsupportedProperties);
-  if (obj !== null && typeof obj === 'object') {
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      if (key === 'additionalProperties') continue;
-      result[key] = stripUnsupportedProperties(value);
-    }
-    return result;
-  }
-  return obj;
-}
-
-/** Convert internal ToolDefinitions to Gemini functionDeclarations. */
-export function toGeminiFunctionDeclarations(
-  tools: ToolDefinition[],
-): GeminiFunctionDeclaration[] {
-  return tools.map((t) => ({
-    name: t.name,
-    description: t.description,
-    parameters: stripUnsupportedProperties(t.parameters) as Record<string, unknown>,
-  }));
-}
-
-/** Parse Gemini response parts into text + ToolCall[]. */
-export function fromGeminiParts(parts: GeminiPart[]): {
-  text: string;
-  toolCalls: ToolCall[];
-} {
-  let text = '';
-  const toolCalls: ToolCall[] = [];
-
-  for (const part of parts) {
-    if (part.text) {
-      text += part.text;
-    } else if (part.functionCall) {
-      toolCalls.push({
-        id: crypto.randomUUID(),
-        name: part.functionCall.name,
-        arguments: part.functionCall.args,
-      });
-    }
-  }
-
-  return { text, toolCalls };
-}
-
-/** Convert internal ProviderMessages to Gemini contents array. */
-export function toGeminiContents(
-  messages: ProviderMessage[],
-  systemPrompt?: string,
-): { contents: GeminiContent[]; systemInstruction?: { parts: GeminiPart[] } } {
-  const contents: GeminiContent[] = [];
-  const systemInstruction = systemPrompt
-    ? { parts: [{ text: systemPrompt }] }
-    : undefined;
-
-  let pendingFunctionResponses: GeminiPart[] = [];
-
-  function flushFunctionResponses(): void {
-    if (pendingFunctionResponses.length > 0) {
-      contents.push({ role: 'user', parts: pendingFunctionResponses });
-      pendingFunctionResponses = [];
-    }
-  }
-
-  for (const msg of messages) {
-    if (msg.role === 'user') {
-      flushFunctionResponses();
-      if (Array.isArray(msg.content)) {
-        // ContentPart[] — convert to Gemini parts
-        const parts: GeminiPart[] = msg.content.map((part: ContentPart) => {
-          if (part.type === 'text') return { text: part.text };
-          return { inlineData: { mimeType: part.mediaType, data: part.data } };
-        });
-        contents.push({ role: 'user', parts });
-      } else {
-        contents.push({ role: 'user', parts: [{ text: msg.content }] });
-      }
-    } else if (msg.role === 'assistant') {
-      flushFunctionResponses();
-      const parts: GeminiPart[] = [];
-      if (msg.content) parts.push({ text: msg.content });
-      if (msg.toolCalls) {
-        for (const tc of msg.toolCalls) {
-          parts.push({ functionCall: { name: tc.name, args: tc.arguments } });
-        }
-      }
-      contents.push({ role: 'model', parts });
-    } else if (msg.role === 'tool') {
-      pendingFunctionResponses.push({
-        functionResponse: {
-          name: msg.name ?? msg.callId,
-          response: { content: msg.content },
-        },
-      });
-    }
-  }
-
-  flushFunctionResponses();
-  return { contents, systemInstruction };
-}
-
-// ---------------------------------------------------------------------------
-// Text-based tool call extraction (for models that emit tool calls as tokens)
-// ---------------------------------------------------------------------------
-
-/**
- * Extracts tool calls from raw text content for models (e.g. kimi-k2-thinking
- * via ollama-cloud) that emit tool calls as text tokens instead of using the
- * OpenAI function-calling wire format.
- *
- * Supports two delimiter formats (both emitted by kimi variants):
- *   Without underscores: <|toolcallbegin|>functions.TOOLNAME:INDEX<|toolcallargumentbegin|>JSON_ARGS<|toolcallend|>
- *   With underscores:    <|tool_call_begin|>functions.TOOLNAME:INDEX<|tool_call_argument_begin|>JSON_ARGS<|tool_call_end|>
- *
- * A trailing <|tool_calls_section_end|> or <|toolcallssectionend|> is also
- * stripped from the cleaned content.
- *
- * @returns Extracted ToolCall array and the content with all tool-call tokens
- * removed (trimmed). Returns empty array when no text-based calls are found.
- */
-export function extractTextToolCalls(content: string): {
-  toolCalls: ToolCall[];
-  cleanedContent: string;
-} {
-  // Fast path: skip regex work when neither sentinel variant is present
-  if (!content.includes('<|toolcallbegin|>') && !content.includes('<|tool_call_begin|>')) {
-    return { toolCalls: [], cleanedContent: content };
-  }
-
-  // Match both delimiter variants using optional underscores.
-  // The `.*?` lazy match with /s is safe here: backtracking is bounded by
-  // the end delimiter, which appears within kilobytes of the argument-begin
-  // delimiter — the span of a single tool call's JSON args.
-  // kimi is the known model that emits these delimiter formats.
-  const pattern =
-    /<\|tool_?call_?begin\|>functions\.([^:]+):\d+<\|tool_?call_?argument_?begin\|>(.*?)<\|tool_?call_?end\|>/gs;
-
-  const toolCalls: ToolCall[] = [];
-  // Build cleaned content in a single pass by collecting match spans,
-  // avoiding a second regex execution over the same string.
-  const segments: string[] = [];
-  let lastEnd = 0;
-  let index = 0;
-
-  for (const match of content.matchAll(pattern)) {
-    const matchStart = match.index!;
-    const matchEnd = matchStart + match[0].length;
-    // Collect the text before this match
-    segments.push(content.slice(lastEnd, matchStart));
-    lastEnd = matchEnd;
-
-    const toolName = match[1];
-    const rawArgs = match[2];
-    toolCalls.push({
-      id: `text-call-${index}`,
-      name: toolName,
-      arguments: parseJson(rawArgs),
-    });
-    index++;
-  }
-  // Append any trailing text after the last match
-  segments.push(content.slice(lastEnd));
-
-  // Strip section-end sentinels (both variants) and trim
-  const cleanedContent = segments
-    .join('')
-    .replace(/<\|tool_?calls_?section_?end\|>/g, '')
-    .trim();
-
-  return { toolCalls, cleanedContent };
-}
-
-// ---------------------------------------------------------------------------
-// Shared helper
-// ---------------------------------------------------------------------------
-
-function parseJson(raw: string): Record<string, unknown> {
-  try {
-    return JSON.parse(raw) as Record<string, unknown>;
-  } catch (err) {
-    logger.warn('tool-formats: failed to parse JSON tool arguments', { error: summarizeError(err) });
-    return {};
-  }
-}

package/src/runtime/auth/inspection.ts

@@ -1,125 +0,0 @@
-import { SecretsManager } from '../../config/secrets.ts';
-import { ServiceRegistry } from '../../config/service-registry.ts';
-import { SubscriptionManager, type ProviderSubscription } from '@pellux/goodvibes-sdk/platform/config/subscriptions';
-import { getSubscriptionProviderConfig } from '../../config/subscription-providers.ts';
-
-export type AuthInspectionFreshness = 'healthy' | 'expiring' | 'expired' | 'pending' | 'available' | 'unconfigured';
-
-export interface ProviderAuthInspection {
-  readonly provider: string;
-  readonly configured: boolean;
-  readonly source?: 'service' | 'builtin';
-  readonly freshness: AuthInspectionFreshness;
-  readonly redirectUri?: string;
-  readonly callbackMode: 'local' | 'manual';
-  readonly localCallback?: string;
-  readonly activeSubscription: boolean;
-  readonly pendingLogin: boolean;
-  readonly overrideAmbientApiKeys: boolean;
-  readonly tokenType?: string;
-  readonly expiresAt?: number;
-  readonly issues: readonly string[];
-  readonly nextActions: readonly string[];
-}
-
-export interface AuthInspectionSnapshot {
-  readonly generatedAt: number;
-  readonly secretKeyCount: number;
-  readonly activeSubscriptions: number;
-  readonly pendingSubscriptions: number;
-  readonly providers: readonly ProviderAuthInspection[];
-}
-
-export interface AuthInspectionDeps {
-  readonly serviceRegistry: Pick<ServiceRegistry, 'get' | 'getAll'>;
-  readonly subscriptionManager: Pick<SubscriptionManager, 'get' | 'getPending' | 'list' | 'listPending'>;
-  readonly secretsManager: Pick<SecretsManager, 'list'>;
-}
-
-function determineFreshness(subscription: ProviderSubscription | null, pending: boolean, configured: boolean): AuthInspectionFreshness {
-  if (pending) return 'pending';
-  if (!subscription) return configured ? 'available' : 'unconfigured';
-  if (typeof subscription.expiresAt !== 'number' || !Number.isFinite(subscription.expiresAt)) return 'healthy';
-  if (subscription.expiresAt <= Date.now()) return 'expired';
-  if (subscription.expiresAt <= Date.now() + 24 * 60 * 60 * 1000) return 'expiring';
-  return 'healthy';
-}
-
-export async function inspectProviderAuth(
-  provider: string,
-  deps: AuthInspectionDeps,
-): Promise<ProviderAuthInspection> {
-  const service = deps.serviceRegistry.get(provider);
-  const resolved = getSubscriptionProviderConfig(provider, service);
-  const subscription = deps.subscriptionManager.get(provider);
-  const pending = deps.subscriptionManager.getPending(provider);
-  const configured = resolved != null;
-  const freshness = determineFreshness(subscription, pending != null, configured);
-  const issues: string[] = [];
-  const nextActions: string[] = [];
-
-  if (!configured) {
-    issues.push('No provider OAuth configuration is available.');
-    nextActions.push(`Add provider OAuth config or a built-in adapter before using /subscription login ${provider} start.`);
-  }
-  if (freshness === 'expired') {
-    issues.push('Stored provider session is expired.');
-    nextActions.push(`Refresh or replace the stored ${provider} session.`);
-  } else if (freshness === 'expiring') {
-    issues.push('Stored provider session expires within 24 hours.');
-    nextActions.push(`Verify or renew the stored ${provider} session soon.`);
-  } else if (freshness === 'pending') {
-    issues.push('OAuth login has started but has not been completed.');
-    nextActions.push(`Finish /subscription login ${provider} finish <code-or-url>.`);
-  } else if (freshness === 'available') {
-    nextActions.push(`Start /subscription login ${provider} start to create a stored session.`);
-  }
-
-  const callbackMode = resolved?.oauth.localCallback ? 'local' : 'manual';
-  const localCallback = resolved?.oauth.localCallback
-    ? `${resolved.oauth.localCallback.host ?? 'localhost'}:${resolved.oauth.localCallback.port ?? 80}${resolved.oauth.localCallback.path ?? '/'}`
-    : undefined;
-
-  return Object.freeze({
-    provider,
-    configured,
-    ...(resolved ? { source: resolved.source } : {}),
-    freshness,
-    ...(resolved ? { redirectUri: resolved.oauth.redirectUri } : {}),
-    callbackMode,
-    ...(localCallback ? { localCallback } : {}),
-    activeSubscription: subscription != null,
-    pendingLogin: pending != null,
-    overrideAmbientApiKeys: subscription?.overrideAmbientApiKeys ?? false,
-    ...(subscription?.tokenType ? { tokenType: subscription.tokenType } : {}),
-    ...(subscription?.expiresAt ? { expiresAt: subscription.expiresAt } : {}),
-    issues,
-    nextActions,
-  });
-}
-
-export async function buildAuthInspectionSnapshot(
-  deps: AuthInspectionDeps,
-): Promise<AuthInspectionSnapshot> {
-  const secrets = await deps.secretsManager.list();
-  const services = deps.serviceRegistry.getAll();
-  const providerIds = new Set<string>([
-    ...Object.values(services)
-      .filter((service) => service.authType === 'oauth' && service.oauth)
-      .map((service) => service.providerId ?? service.name),
-    ...deps.subscriptionManager.list().map((entry) => entry.provider),
-    ...deps.subscriptionManager.listPending().map((entry) => entry.provider),
-  ]);
-  const providers = await Promise.all(
-    [...providerIds]
-      .sort((a, b) => a.localeCompare(b))
-      .map((provider) => inspectProviderAuth(provider, deps)),
-  );
-  return Object.freeze({
-    generatedAt: Date.now(),
-    secretKeyCount: secrets.length,
-    activeSubscriptions: deps.subscriptionManager.list().length,
-    pendingSubscriptions: deps.subscriptionManager.listPending().length,
-    providers,
-  });
-}