@aria-cli/types 1.0.9 → 1.0.11

package/src/models.ts

@@ -1,356 +0,0 @@
-/**
- * Types for ARIA's multi-model system
- * @module @aria/types/models
- */
-
-import type { NativeToolMetadata } from "./native-tools.js";
-
-/**
- * Supported model providers
- */
-export type ModelProvider =
-  | "anthropic"
-  | "openai"
-  | "github-copilot"
-  | "openai-codex"
-  | "google"
-  | "local"
-  | "bedrock"
-  | "bedrock-converse";
-
-/**
- * Model tier for task routing
- * - 'fast': Quick responses, simple tasks (e.g., Haiku, GPT-4o-mini)
- * - 'balanced': Good balance of speed and capability (e.g., Sonnet, GPT-5.2)
- * - 'powerful': Maximum capability for complex tasks (e.g., Opus, o1)
- * - 'ensemble': Multiple models working together
- */
-export type ModelTier = "fast" | "balanced" | "powerful" | "ensemble";
-
-/**
- * Configuration for a specific model
- */
-export interface ModelConfig {
-  /** Model provider */
-  provider: ModelProvider;
-  /** Model identifier (e.g., 'claude-opus-4-6') */
-  modelId: string;
-  /** Human-readable name */
-  name: string;
-  /** Model tier classification */
-  tier: ModelTier;
-  /** Maximum context window size in tokens */
-  maxContextTokens: number;
-  /** Maximum output tokens */
-  maxOutputTokens: number;
-  /** Cost per million input tokens (USD) */
-  inputCostPerMillion: number;
-  /** Cost per million output tokens (USD) */
-  outputCostPerMillion: number;
-  /** Capabilities this model supports */
-  capabilities: {
-    /** Supports tool/function calling */
-    tools: boolean;
-    /** Supports vision/image input */
-    vision: boolean;
-    /** Supports structured output (JSON mode) */
-    structuredOutput: boolean;
-    /** Supports streaming responses */
-    streaming: boolean;
-  };
-  /** API endpoint (for local/custom providers) */
-  endpoint?: string;
-  /** Additional provider-specific options */
-  options?: Record<string, unknown>;
-}
-
-/**
- * Configuration for the model router
- */
-export interface ModelRouterConfig {
-  /** Default model tier to use */
-  defaultTier: ModelTier;
-  /** Available models by tier */
-  models: {
-    fast: ModelConfig[];
-    balanced: ModelConfig[];
-    powerful: ModelConfig[];
-    ensemble?: ModelConfig[];
-  };
-  /** Rules for automatic tier selection */
-  routingRules: {
-    /** Use powerful tier for tasks with risk above this level */
-    riskThreshold: number;
-    /** Use powerful tier for tasks with complexity above this score */
-    complexityThreshold: number;
-    /** Maximum cost per request before requiring approval (USD) */
-    costThreshold: number;
-  };
-  /** Fallback model if primary fails */
-  fallbackModel?: ModelConfig;
-}
-
-/**
- * Role of a message in a conversation
- */
-export type MessageRole = "system" | "user" | "assistant" | "tool";
-
-/**
- * A message in a conversation
- */
-export interface Message {
-  /** Role of the message sender */
-  role: MessageRole;
-  /** Text content of the message */
-  content: string;
-  /** Name of the sender (optional) */
-  name?: string;
-  /** Tool call ID this message is responding to (for tool role) */
-  toolCallId?: string;
-  /** Tool calls requested by the assistant for execution (present on assistant messages with tool_use blocks) */
-  toolCalls?: ToolCall[];
-  /** Image attachments (for vision models) */
-  images?: {
-    /** Base64 encoded image data or URL */
-    data: string;
-    /** MIME type of the image */
-    mimeType: string;
-  }[];
-}
-
-/**
- * JSON Schema for function tool parameters
- */
-export interface FunctionToolParameters {
-  type: "object";
-  properties: Record<string, unknown>;
-  required?: string[];
-  [key: string]: unknown;
-}
-
-/**
- * Function tool schema (standard ARIA tool)
- */
-export interface FunctionToolSchema {
-  kind: "function";
-  name: string;
-  description: string;
-  parameters: FunctionToolParameters;
-  /** When true, the provider defers loading this tool until needed */
-  defer_loading?: boolean;
-  /** Native-only fields are forbidden on function tools */
-  provider?: never;
-  capability?: never;
-  config?: never;
-  suppresses?: never;
-}
-
-/**
- * Provider-native passthrough tool schema
- */
-export interface NativeToolSchema {
-  kind: "native";
-  /** Provider that supplies this native tool */
-  provider: "anthropic" | "openai" | "google";
-  /** Native capability identifier */
-  capability: string;
-  /** Provider-specific native tool payload */
-  config: Record<string, unknown>;
-  /** ARIA function tools suppressed by this native tool */
-  suppresses?: string[];
-  /** Function-only fields are forbidden on native tools */
-  name?: never;
-  description?: never;
-  parameters?: never;
-  defer_loading?: never;
-}
-
-/**
- * Tool schema for model requests (discriminated by `kind`)
- */
-export type ToolSchema = FunctionToolSchema | NativeToolSchema;
-
-/**
- * Type guard for function tools
- */
-export function isFunctionToolSchema(tool: ToolSchema): tool is FunctionToolSchema {
-  return tool.kind === "function";
-}
-
-/**
- * Type guard for native tools
- */
-export function isNativeToolSchema(tool: ToolSchema): tool is NativeToolSchema {
-  return tool.kind === "native";
-}
-
-/**
- * A tool call requested by the model
- */
-export interface ToolCall {
-  /** Unique identifier for this tool call */
-  id: string;
-  /** Name of the tool to call */
-  name: string;
-  /** Arguments to pass to the tool */
-  arguments: Record<string, unknown>;
-  /** Gemini thought signature — must be replayed verbatim in conversation history */
-  thoughtSignature?: string;
-}
-
-/**
- * Thinking mode for models that support extended reasoning.
- * - 'adaptive': Model decides when and how much to think (Opus 4.6+, recommended)
- * - 'enabled': Explicit thinking with a token budget (Sonnet 4.5, Opus 4.5)
- */
-export type ThinkingMode = "adaptive" | "enabled";
-
-/**
- * Configuration for extended thinking/reasoning
- */
-export interface ThinkingConfig {
-  /** Thinking mode */
-  mode: ThinkingMode;
-  /** Token budget for thinking (required for 'enabled' mode, ignored for 'adaptive') */
-  budgetTokens?: number;
-}
-
-/**
- * Effort level controlling reasoning depth vs speed/cost.
- * - 'low': Fastest, cheapest. Skips thinking for simple tasks.
- * - 'medium': Balanced. May skip thinking for very simple queries.
- * - 'high': Default. Deep reasoning on complex tasks.
- * - 'max': Maximum capability, no constraints. Opus 4.6 only.
- */
-export type EffortLevel = "low" | "medium" | "high" | "max";
-
-/**
- * A thinking block from a model's internal reasoning process
- */
-export interface ThinkingBlock {
-  /** The thinking text content (empty string if redacted) */
-  thinking: string;
-  /** Cryptographic signature for verification (required for tool-use continuations) */
-  signature?: string;
-  /** Whether this block was redacted by safety systems */
-  redacted?: boolean;
-}
-
-/**
- * Request to a model
- */
-export interface ModelRequest {
-  /** Messages in the conversation */
-  messages: Message[];
-  /** System prompt (if not in messages) */
-  systemPrompt?: string;
-  /** Available tools */
-  tools?: ToolSchema[];
-  /** Temperature for sampling (0-2) */
-  temperature?: number;
-  /** Maximum tokens to generate */
-  maxTokens?: number;
-  /** Stop sequences */
-  stopSequences?: string[];
-  /** Whether to stream the response */
-  stream?: boolean;
-  /** Force structured JSON output */
-  jsonMode?: boolean;
-  /** Extended thinking configuration */
-  thinking?: ThinkingConfig;
-  /** Effort level for response quality vs speed/cost tradeoff */
-  effort?: EffortLevel;
-  /** Tool choice strategy (e.g. "auto", "none", or a specific tool name) */
-  tool_choice?: string;
-  /** Request metadata */
-  metadata?: {
-    /** Task ID for tracking */
-    taskId?: string;
-    /** User ID for billing */
-    userId?: string;
-    /** Request priority */
-    priority?: "low" | "normal" | "high";
-  };
-  /** Callback for streaming thinking blocks as they arrive (Gemini 2.5+/3.x).
-   *  Allows the runner to yield thinking events during model streaming
-   *  instead of waiting for the full response. */
-  onThinking?: (text: string) => void;
-  /** AbortSignal for cancelling in-flight HTTP requests.
-   *  Passed through to provider fetch() calls so Ctrl+C cancels immediately
-   *  instead of waiting for the next network chunk. */
-  abortSignal?: AbortSignal;
-}
-
-/** Capabilities that a model provider supports */
-export interface ProviderCapabilities {
-  /** Whether the provider supports structured JSON output */
-  jsonMode: boolean;
-  /** Whether the provider supports extended thinking */
-  thinking: boolean;
-  /** Whether the provider supports tool/function calling */
-  toolUse: boolean;
-  /** Whether the provider supports streaming responses */
-  streaming: boolean;
-  /** Whether the provider supports native defer_loading on tool schemas */
-  nativeDeferredLoading: boolean;
-  /** Whether the provider supports native web search */
-  nativeSearch: boolean;
-  /** Whether the provider supports native web fetch */
-  nativeFetch: boolean;
-  /** Whether the provider supports native code execution */
-  nativeCodeExec: boolean;
-  /** Whether the provider supports native computer use */
-  nativeComputerUse: boolean;
-  /** Whether the provider supports native image generation */
-  nativeImageGen: boolean;
-  /** Whether the provider supports native file search */
-  nativeFileSearch: boolean;
-}
-
-/**
- * Usage statistics from a model response
- */
-export interface ModelUsage {
-  /** Input tokens consumed (TOTAL context window — includes cached tokens) */
-  inputTokens: number;
-  /** Output tokens generated */
-  outputTokens: number;
-  /** Total tokens (input + output) */
-  totalTokens: number;
-  /** Estimated cost in USD */
-  estimatedCost: number;
-  /** Thinking tokens consumed (subset of outputTokens, if available) */
-  thinkingTokens?: number;
-  /** Tokens read from prompt cache (subset of inputTokens) */
-  cacheReadTokens?: number;
-  /** Tokens written to prompt cache (subset of inputTokens) */
-  cacheCreationTokens?: number;
-}
-
-/**
- * Response from a model
- */
-export interface ModelResponse {
-  /** The model's text response */
-  content: string;
-  /** Tool calls requested by the model */
-  toolCalls?: ToolCall[];
-  /** Why the model stopped generating */
-  stopReason: "end" | "max_tokens" | "tool_call" | "stop_sequence" | "aborted";
-  /** Token usage statistics */
-  usage: ModelUsage;
-  /** Model that generated the response */
-  model: string;
-  /** Response generation time in milliseconds */
-  latency: number;
-  /** Unique ID for this response */
-  responseId: string;
-  /** Thinking blocks from the model's reasoning process */
-  thinking?: ThinkingBlock[];
-  /** Raw content blocks from the API (for tool-use continuations with thinking) */
-  rawContentBlocks?: unknown[];
-  /** Provider that generated the response */
-  provider?: ModelProvider;
-  /** Native tool metadata (e.g., search results, code exec output) */
-  nativeToolMetadata?: NativeToolMetadata;
-}

package/src/native-tools.ts

@@ -1,73 +0,0 @@
-/**
- * Native tool types and type guards for provider-native capabilities
- * @module @aria/types/native-tools
- */
-
-import type { ToolCall } from "./models.js";
-
-/**
- * Type guard to check if a tool call is a function/custom tool
- * (as opposed to a native provider tool like search or code execution)
- */
-export function isFunctionTool(toolCall: ToolCall): boolean {
-  // Function tools are the default - they don't have special name prefixes
-  return !isNativeTool(toolCall);
-}
-
-/**
- * Type guard to check if a tool call is a native provider tool
- * Native tools have special name prefixes like "brave_search", "computer", etc.
- */
-export function isNativeTool(toolCall: ToolCall): boolean {
-  const nativePrefixes = [
-    "brave_search",
-    "computer",
-    "code_interpreter",
-    "text_editor",
-    "bash",
-    "dalle",
-    "file_search",
-  ];
-  return nativePrefixes.some((prefix) => toolCall.name.startsWith(prefix));
-}
-
-/**
- * A single source from a search result
- */
-export interface NormalizedSource {
-  /** URL of the source */
-  url: string;
-  /** Title of the source */
-  title: string;
-  /** Optional snippet/excerpt from the source */
-  snippet?: string;
-  /** Confidence score (0-1) if provided by the search API */
-  confidence?: number;
-  /** Which segments of the response cited this source */
-  citedSegments?: Array<{ text: string; startIndex: number; endIndex: number }>;
-}
-
-/**
- * Normalized metadata for native search tool calls
- * Abstracts over provider-specific search APIs (Anthropic Brave, Google Search, etc.)
- */
-export interface NormalizedSearchMetadata {
-  /** Provider that executed the search */
-  provider: "anthropic" | "openai" | "google";
-  /** Search queries executed (may be multiple if refined) */
-  queries: string[];
-  /** Sources returned by the search */
-  sources: NormalizedSource[];
-  /** The grounded response generated from search results (if available) */
-  groundedResponse?: string;
-}
-
-/**
- * Metadata attached to ModelResponse when native tools are used
- */
-export interface NativeToolMetadata {
-  /** Search metadata (if native search was used) */
-  search?: NormalizedSearchMetadata;
-  /** Raw provider-specific metadata for other native tools */
-  raw?: unknown;
-}

package/src/relaunch.ts

@@ -1,67 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
-
-/**
- * Magic exit code that tells the parent supervisor to respawn the child.
- */
-export const RELAUNCH_EXIT_CODE = 199;
-
-/**
- * Environment variables used by relaunch/supervisor flows.
- */
-export const NO_RELAUNCH_ENV = "ARIA_NO_RELAUNCH";
-export const RESUME_SESSION_ENV = "ARIA_RESUME_SESSION_ID";
-export const RESUME_ARION_ENV = "ARIA_RESUME_ARION";
-export const RESTART_KIND_ENV = "ARIA_RESTART_KIND";
-
-export interface RelaunchMarker {
-  sessionId: string | null;
-  arionName: string;
-  pid: number;
-  timestamp: string; // ISO 8601
-}
-
-function getAriaDir(): string {
-  const ariaHome = process.env.ARIA_HOME?.trim();
-  if (ariaHome) return ariaHome;
-  return join(homedir(), ".aria");
-}
-
-export function getRelaunchMarkerDir(): string {
-  return join(getAriaDir(), "relaunch-pending");
-}
-
-export function getRelaunchMarkerPath(pid: number = process.pid): string {
-  return join(getRelaunchMarkerDir(), `${pid}.json`);
-}
-
-export function writeRelaunchMarker(marker: RelaunchMarker): void {
-  try {
-    const markerPath = getRelaunchMarkerPath(marker.pid);
-    mkdirSync(dirname(markerPath), { recursive: true });
-    writeFileSync(markerPath, JSON.stringify(marker), "utf-8");
-  } catch {
-    // Best-effort — must never prevent restart
-  }
-}
-
-export function readRelaunchMarker(pid: number = process.pid): RelaunchMarker | null {
-  try {
-    const markerPath = getRelaunchMarkerPath(pid);
-    if (!existsSync(markerPath)) return null;
-    const raw = readFileSync(markerPath, "utf-8");
-    return JSON.parse(raw) as RelaunchMarker;
-  } catch {
-    return null;
-  }
-}
-
-export function clearRelaunchMarker(pid: number = process.pid): void {
-  try {
-    const markerPath = getRelaunchMarkerPath(pid);
-    if (existsSync(markerPath)) unlinkSync(markerPath);
-  } catch {
-    // Best-effort
-  }
-}

package/src/stall-phase.ts

@@ -1,20 +0,0 @@
-type StallPhaseGlobal = typeof globalThis & {
-  __aria_stall_phase?: string;
-  __aria_stall_phase_ts?: number;
-};
-
-function getGlobalPhaseStore(): StallPhaseGlobal {
-  return globalThis as StallPhaseGlobal;
-}
-
-export function setGlobalStallPhase(label: string): void {
-  const store = getGlobalPhaseStore();
-  store.__aria_stall_phase = label;
-  store.__aria_stall_phase_ts = performance.now();
-}
-
-export function clearGlobalStallPhase(): void {
-  const store = getGlobalPhaseStore();
-  store.__aria_stall_phase = undefined;
-  store.__aria_stall_phase_ts = undefined;
-}

package/src/tool-outputs.ts

@@ -1,42 +0,0 @@
-/** Canonical output shapes for tools with dedicated renderers.
- *  Executors MUST return these shapes. Renderers consume them directly. */
-
-export interface EditFileOutput {
-  filePath: string;
-  structuredPatch: Array<{
-    oldStart: number;
-    oldLines: number;
-    newStart: number;
-    newLines: number;
-    lines: string[];
-  }>;
-  replacements: number;
-  strategy: string;
-}
-
-export interface WriteFileOutput {
-  filePath: string;
-  action: "created" | "overwritten" | "appended";
-  bytesWritten: number;
-  structuredPatch?: Array<{
-    oldStart: number;
-    oldLines: number;
-    newStart: number;
-    newLines: number;
-    lines: string[];
-  }>;
-}
-
-// BashToolOutput matches @aria/tools BashOutput (shell.ts:255-259)
-export interface BashToolOutput {
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-}
-
-export interface NotebookEditOutput {
-  cellNumber: number;
-  newSource: string;
-  language: string;
-  error?: string;
-}

package/tests/guards/types-test-lane-manifest.contract.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  PACKAGE_TEST_AUTHORITY,
-  classifyTypesTestFile,
-  classifyTypesTestPlacement,
-  classifyTypesTestProofClass,
-  loadTypesTestLaneManifest,
-  type TypesTestLaneId,
-} from "../test-lane-manifest.js";
-
-function expectLane(relativePath: string, expected: TypesTestLaneId): void {
-  expect(classifyTypesTestFile(relativePath)).toBe(expected);
-}
-
-describe("types test lane manifest", () => {
-  it("classifies every types test file into an explicit lane and proof class", () => {
-    const manifest = loadTypesTestLaneManifest();
-
-    expect(manifest.defaultLane).toBe("unit");
-    expect(manifest.unclassified).toEqual([]);
-    expect(manifest.unclassifiedProofClasses).toEqual([]);
-    expect(manifest.proofClasses.gate.length).toBeGreaterThan(0);
-    expect(manifest.proofClasses.system).toEqual([]);
-    expect(manifest.proofClasses.live).toEqual([]);
-  });
-
-  it("keeps the current types package entirely in the default gate lane", () => {
-    expectLane("tests/logger.test.ts", "unit");
-    expect(classifyTypesTestProofClass("tests/logger.test.ts")).toBe("gate");
-    expect(classifyTypesTestPlacement("tests/logger.test.ts")).toMatchObject({
-      lane: "unit",
-      proofClass: "gate",
-      resourceKeys: [],
-    });
-  });
-
-  it("exposes package test authority projections for proof ownership", () => {
-    expect(PACKAGE_TEST_AUTHORITY.classifyProofClass("tests/logger.test.ts")).toBe("gate");
-    expect(PACKAGE_TEST_AUTHORITY.getProofClassFiles("gate")).toContain("tests/logger.test.ts");
-    expect(PACKAGE_TEST_AUTHORITY.getDiagnosticBreadthFiles("unit")).toContain("tests/logger.test.ts");
-  });
-});