@lasso-ai/cli 2.1.23 → 2.1.25

package/dist/core/interfaces/agent-runtime.d.ts

@@ -0,0 +1,308 @@
+/**
+ * Lasso Agentic Runtime - Core Type Definitions
+ *
+ * This file defines all the core contracts for the Lasso-owned agentic runtime.
+ * The model is an interchangeable intelligence provider; Lasso owns the loop.
+ */
+export type AgentPhase = "understand" | "inspect" | "plan" | "execute" | "verify" | "recover" | "complete";
+export type AgentStatus = "running" | "waiting" | "completed" | "failed" | "cancelled";
+export interface LassoAgentSession {
+    id: string;
+    phase: AgentPhase;
+    status: AgentStatus;
+    iteration: number;
+    userPrompt: string;
+    conversation: AgentMessage[];
+    observations: Observation[];
+    actions: AgentAction[];
+    completedActions: AgentAction[];
+    errors: AgentError[];
+    plan?: AgentPlan;
+    selection?: SelectionContext;
+    project: ProjectContext;
+    model: ModelMetadata;
+    createdAt: Date;
+    updatedAt: Date;
+    conversationUid?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface AgentMessage {
+    id: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    timestamp: number;
+    metadata?: Record<string, unknown>;
+}
+export interface SelectionContext {
+    element?: {
+        tag: string;
+        text?: string;
+        source?: string;
+        attributes?: Record<string, string>;
+    };
+    viewport?: {
+        width: number;
+        height: number;
+        scrollY?: number;
+        scrollHeight?: number;
+    };
+    route?: string;
+    screenshot?: string;
+}
+export interface ProjectContext {
+    projectId: string;
+    framework?: string;
+    hasTypeScript: boolean;
+    hasTailwind: boolean;
+    hasReact: boolean;
+    hasNext: boolean;
+    hasVite: boolean;
+    files: string[];
+    dependencies?: string[];
+    devDependencies?: string[];
+    currentRoute?: string;
+    sourceHints?: Record<string, string>;
+    pageContext?: {
+        route?: string;
+        title?: string;
+        viewport?: {
+            width: number;
+            height: number;
+            scrollY?: number;
+            scrollHeight?: number;
+        };
+        domSummary?: {
+            headings?: Array<{
+                level: number;
+                text: string;
+            }>;
+            sections?: Array<{
+                name: string;
+                textPreview: string;
+            }>;
+            buttons?: string[];
+            links?: string[];
+            visibleTextSnippet?: string;
+        };
+        runtimeErrors?: string[];
+        selectedElement?: SelectionContext["element"];
+        screenshot?: string;
+    };
+}
+export interface AgentPlan {
+    id: string;
+    goal: string;
+    steps: PlanStep[];
+    estimatedActions?: number;
+    createdAt: Date;
+}
+export interface PlanStep {
+    id: string;
+    description: string;
+    status: "pending" | "in_progress" | "completed" | "failed";
+    actionCount?: number;
+}
+export type ObservationType = "file" | "search" | "command" | "browser" | "build" | "runtime" | "error" | "verification" | "tool";
+export interface Observation {
+    id: string;
+    type: ObservationType;
+    summary: string;
+    data?: unknown;
+    timestamp: number;
+    phase?: AgentPhase;
+    actionId?: string;
+}
+export type AgentAction = ReadFileAction | SearchCodeAction | InspectProjectAction | EditFileAction | CreateFileAction | DeleteFileAction | RunCommandAction | BrowserCheckAction;
+export interface BaseAction {
+    id: string;
+    data: Record<string, unknown>;
+}
+export interface ReadFileAction extends BaseAction {
+    type: "read_file";
+}
+export interface SearchCodeAction extends BaseAction {
+    type: "search_code";
+}
+export interface InspectProjectAction extends BaseAction {
+    type: "inspect_project";
+}
+export interface EditFileAction extends BaseAction {
+    type: "edit_file";
+}
+export interface CreateFileAction extends BaseAction {
+    type: "create_file";
+}
+export interface DeleteFileAction extends BaseAction {
+    type: "delete_file";
+}
+export interface RunCommandAction extends BaseAction {
+    type: "run_command";
+}
+export interface BrowserCheckAction extends BaseAction {
+    type: "browser_check";
+}
+export interface AgentError {
+    id: string;
+    type: "validation" | "execution" | "verification" | "timeout" | "permission" | "unknown";
+    message: string;
+    phase: AgentPhase;
+    actionId?: string;
+    timestamp: number;
+    details?: Record<string, unknown>;
+    recoverable: boolean;
+}
+export interface ModelMetadata {
+    provider: "anthropic" | "openai" | "google" | "nvidia" | "ollama" | "claude_code" | "opencode" | "codex_cli" | "cursor";
+    id: string;
+    name?: string;
+}
+export interface LassoAgentContext {
+    session: {
+        id: string;
+        phase: AgentPhase;
+        iteration: number;
+    };
+    userPrompt: string;
+    conversation: AgentMessage[];
+    selection?: SelectionContext;
+    project: ProjectContext;
+    observations: Observation[];
+    previousActions: AgentAction[];
+    errors: AgentError[];
+    currentPlan?: AgentPlan;
+    availableTools: ToolDefinition[];
+    constraints: AgentConstraints;
+}
+export interface ToolDefinition {
+    name: string;
+    description: string;
+    allowedPhases: AgentPhase[];
+    parameters?: Record<string, unknown>;
+}
+export interface AgentConstraints {
+    maxActionsPerTurn: number;
+    allowedPhases: AgentPhase[];
+    maxFileSize?: number;
+    allowedCommands?: string[];
+    forbiddenPaths?: string[];
+    safetyLevel?: "strict" | "standard" | "permissive";
+}
+export interface LassoModelResponse {
+    status: "continue" | "waiting" | "complete" | "failed";
+    reasoning: {
+        summary: string;
+        /** Raw model thoughts / extended reasoning, when the provider exposes it. */
+        raw?: string;
+    };
+    decision: {
+        type: "respond" | "inspect" | "plan" | "execute" | "verify" | "recover" | "ask_user";
+        goal: string;
+    };
+    actions: AgentAction[];
+    /** Direct conversational answer when no project work is requested. */
+    reply?: string;
+    expectedOutcome?: string;
+}
+export type AgentEventType = "agent_started" | "agent_reasoning" | "agent_completed" | "agent_failed" | "agent_cancelled" | "phase_changed" | "tool_started" | "tool_completed" | "tool_call" | "observation" | "plan_created" | "file_changed" | "verification_started" | "verification_completed" | "error" | "model_changed" | "waiting_for_user";
+export interface AgentEvent {
+    type: AgentEventType;
+    sessionId: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+export interface AgentReasoningEvent extends AgentEvent {
+    type: "agent_reasoning";
+    data: {
+        summary: string;
+        decision?: string;
+        /** Raw model thoughts for UI detail display. */
+        raw?: string;
+    };
+}
+export interface PhaseChangedEvent extends AgentEvent {
+    type: "phase_changed";
+    data: {
+        from: AgentPhase;
+        to: AgentPhase;
+        reason?: string;
+    };
+}
+export interface ToolStartedEvent extends AgentEvent {
+    type: "tool_started";
+    data: {
+        actionType: string;
+        target?: string;
+    };
+}
+export interface ToolCompletedEvent extends AgentEvent {
+    type: "tool_completed";
+    data: {
+        actionType: string;
+        target?: string;
+        success: boolean;
+        duration?: number;
+    };
+}
+/**
+ * Emitted by the server when the hosted model requests a workspace tool.
+ * The local CLI executes the tool and posts the result back to
+ * `POST /sessions/:sessionId/tool-results` (see tool-protocol.ts).
+ */
+export interface ToolCallEvent extends AgentEvent {
+    type: "tool_call";
+    data: {
+        callId: string;
+        kind: "action" | "verify";
+        action?: AgentAction;
+        verify?: {
+            phase?: string;
+        };
+    };
+}
+export interface ObservationEvent extends AgentEvent {
+    type: "observation";
+    data: {
+        observationType: ObservationType;
+        summary: string;
+        details?: unknown;
+    };
+}
+export interface VerificationStartedEvent extends AgentEvent {
+    type: "verification_started";
+    data: {
+        verificationType: "typecheck" | "build" | "runtime" | "browser";
+    };
+}
+export interface VerificationCompletedEvent extends AgentEvent {
+    type: "verification_completed";
+    data: {
+        verificationType: "typecheck" | "build" | "runtime" | "browser";
+        success: boolean;
+        duration?: number;
+        errors?: string[];
+    };
+}
+export interface ErrorEvent extends AgentEvent {
+    type: "error";
+    data: {
+        errorType: string;
+        message: string;
+        phase: AgentPhase;
+        recoverable: boolean;
+    };
+}
+export interface ModelChangedEvent extends AgentEvent {
+    type: "model_changed";
+    data: {
+        from: ModelMetadata;
+        to: ModelMetadata;
+    };
+}
+export interface WaitingForUserEvent extends AgentEvent {
+    type: "waiting_for_user";
+    data: {
+        question?: string;
+        options?: string[];
+        kind?: "input" | "single_select" | "multiselect";
+    };
+}

package/dist/core/interfaces/agent-runtime.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Lasso Agentic Runtime - Core Type Definitions
+ *
+ * This file defines all the core contracts for the Lasso-owned agentic runtime.
+ * The model is an interchangeable intelligence provider; Lasso owns the loop.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/interfaces/backend.d.ts

@@ -0,0 +1,274 @@
+/**
+ * Lasso Backend Interface - Unified Abstraction for Agent Backends
+ *
+ * This file defines the common interface for all agent backends:
+ * - Hosted model providers (Anthropic, OpenAI, Google, NVIDIA, Ollama)
+ * - Local coding agents (Claude Code, OpenCode, Codex CLI, Cursor)
+ *
+ * The Lasso Runtime uses this interface to delegate task execution while maintaining
+ * control over the overall workflow: Understand → Inspect → Plan → Execute → Verify → Recover → Complete
+ */
+import { AgentAction, Observation, AgentError, AgentPhase, ProjectContext, SelectionContext } from "./agent-runtime";
+export type { AgentAction, Observation, AgentError, AgentPhase, ProjectContext, SelectionContext } from "./agent-runtime";
+export type BackendType = "hosted_model" | "local_agent";
+export type BackendProvider = "anthropic" | "openai" | "google" | "nvidia" | "ollama" | "claude_code" | "opencode" | "codex_cli" | "cursor";
+export interface BackendCapabilities {
+    /**
+     * Whether the backend can stream progress events in real-time
+     */
+    canStreamEvents: boolean;
+    /**
+     * Whether the backend can operate in an isolated workspace
+     * (required for safe pre-review execution)
+     */
+    canIsolateWorkspace: boolean;
+    /**
+     * Whether the backend provides structured diff output
+     * (vs. requiring post-execution diff generation)
+     */
+    providesStructuredDiffs: boolean;
+    /**
+     * Whether the backend supports session continuation across calls
+     */
+    supportsSessionContinuation: boolean;
+    /**
+     * Whether the backend can cancel running tasks
+     */
+    supportsCancellation: boolean;
+    /**
+     * Whether the backend has its own internal agentic loop
+     * (if true, Lasso should not run a competing loop around it)
+     */
+    hasInternalLoop: boolean;
+    /**
+     * File operations the backend can perform directly
+     */
+    supportedFileOperations: "read" | "write" | "both" | "none";
+    /**
+     * Whether the backend can run shell commands
+     */
+    canRunCommands: boolean;
+    /**
+     * Authentication method
+     */
+    authMethod: "api_key" | "cli_session" | "none" | "oauth";
+    /**
+     * Maximum file size for operations (in bytes), if any
+     */
+    maxFileSize?: number;
+    /**
+     * Commands that are forbidden (if any)
+     */
+    forbiddenCommands?: string[];
+}
+export interface BackendConfig {
+    /**
+     * Backend type
+     */
+    type: BackendType;
+    /**
+     * Provider identifier
+     */
+    provider: BackendProvider;
+    /**
+     * Model ID (for hosted models) or agent version (for local agents)
+     */
+    modelId?: string;
+    /**
+     * API key (for hosted models)
+     */
+    apiKey?: string;
+    /**
+     * Base URL (for hosted models like Ollama)
+     */
+    baseURL?: string;
+    /**
+     * Project path (for local agents)
+     */
+    projectPath?: string;
+    /**
+     * Additional provider-specific configuration
+     */
+    providerConfig?: Record<string, unknown>;
+}
+export interface TaskContext {
+    /**
+     * Unique task identifier
+     */
+    taskId: string;
+    /**
+     * User's prompt or instruction
+     */
+    userPrompt: string;
+    /** Whether the backend should answer conversationally without project work. */
+    mode?: "conversation" | "task";
+    /**
+     * Project context
+     */
+    project: ProjectContext;
+    /**
+     * Selection context (if user selected a UI element)
+     */
+    selection?: SelectionContext;
+    /**
+     * Conversation history
+     */
+    conversation: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp: number;
+    }>;
+    /**
+     * Previous observations (for context)
+     */
+    previousObservations: Observation[];
+    /**
+     * Previous errors (for recovery)
+     */
+    previousErrors: AgentError[];
+    /**
+     * Current phase in Lasso's workflow
+     */
+    currentPhase: AgentPhase;
+    /**
+     * Constraints (max actions, safety level, etc.)
+     */
+    constraints: {
+        maxActions?: number;
+        safetyLevel?: "strict" | "standard" | "permissive";
+        allowedCommands?: string[];
+        forbiddenPaths?: string[];
+    };
+    /**
+     * Reference to the backend's own external session (e.g. Claude Code session id,
+     * Codex thread id, OpenCode ses_ id) for continuation when supported.
+     */
+    sessionRef?: {
+        id?: string;
+    };
+}
+export type BackendEventType = "task_started" | "task_progress" | "tool_started" | "tool_completed" | "file_read" | "file_modified" | "file_created" | "file_deleted" | "diff_available" | "verification_started" | "verification_completed" | "error" | "waiting_for_user" | "task_completed" | "task_cancelled" | "task_failed";
+export interface BackendEvent {
+    type: BackendEventType;
+    taskId: string;
+    timestamp: number;
+    data?: Record<string, unknown>;
+}
+export interface BackendResult {
+    /**
+     * Whether the task completed successfully
+     */
+    success: boolean;
+    /**
+     * Final status
+     */
+    status: "completed" | "failed" | "cancelled" | "waiting";
+    /**
+     * Summary of what was done
+     */
+    summary: string;
+    /**
+     * File changes detected (normalized format)
+     */
+    fileChanges: Array<{
+        filePath: string;
+        operation: "created" | "modified" | "deleted";
+        oldContent?: string;
+        newContent?: string;
+    }>;
+    /**
+     * Actions taken (normalized to Lasso's AgentAction format where possible)
+     */
+    actions: AgentAction[];
+    /**
+     * Observations collected
+     */
+    observations: Observation[];
+    /**
+     * Errors encountered
+     */
+    errors: AgentError[];
+    /**
+     * Final conversation state (for continuation)
+     */
+    conversation?: Array<{
+        role: "user" | "assistant" | "system";
+        content: string;
+        timestamp: number;
+    }>;
+    /**
+     * Provider-specific metadata
+     */
+    metadata?: Record<string, unknown>;
+}
+export interface IBackend {
+    /**
+     * Unique backend identifier
+     */
+    id: string;
+    /**
+     * Backend type
+     */
+    type: BackendType;
+    /**
+     * Provider name
+     */
+    provider: BackendProvider;
+    /**
+     * Model/agent ID
+     */
+    modelId: string;
+    /**
+     * Get backend capabilities
+     */
+    getCapabilities(): BackendCapabilities;
+    /**
+     * Check if backend is available and properly configured
+     *
+     * Returns detailed availability info including any authentication issues
+     */
+    checkAvailability(): Promise<{
+        available: boolean;
+        installed: boolean;
+        authenticated: boolean;
+        version?: string;
+        error?: string;
+        fixInstructions?: string;
+    }>;
+    /**
+     * Execute a task
+     *
+     * This is the main entry point for task execution.
+     * The backend should:
+     * 1. Start the task
+     * 2. Stream progress events via the callback
+     * 3. Return the final result
+     *
+     * For backends with internal loops (like Claude Code), this method
+     * should delegate to the agent and monitor its execution.
+     *
+     * For hosted models, this method should integrate with the existing
+     * ModelGateway and return structured responses.
+     */
+    executeTask(context: TaskContext, onEvent: (event: BackendEvent) => void, signal?: AbortSignal): Promise<BackendResult>;
+    /**
+     * Cancel a running task
+     *
+     * Only called if supportsCancellation is true
+     */
+    cancelTask(taskId: string): Promise<void>;
+    /**
+     * Switch to a different backend/model
+     *
+     * This is called when the user switches providers mid-session.
+     * The backend should:
+     * 1. Return any context that can be transferred
+     * 2. Report what cannot be transferred (e.g., internal state)
+     */
+    switchBackend(newBackend: IBackend, context: TaskContext): Promise<{
+        transferableContext: Record<string, unknown>;
+        lostContext: string[];
+    }>;
+}
+export declare const DEFAULT_LOCAL_CAPABILITIES: BackendCapabilities;
+export declare const DEFAULT_HOSTED_CAPABILITIES: BackendCapabilities;

package/dist/core/interfaces/backend.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Lasso Backend Interface - Unified Abstraction for Agent Backends
+ *
+ * This file defines the common interface for all agent backends:
+ * - Hosted model providers (Anthropic, OpenAI, Google, NVIDIA, Ollama)
+ * - Local coding agents (Claude Code, OpenCode, Codex CLI, Cursor)
+ *
+ * The Lasso Runtime uses this interface to delegate task execution while maintaining
+ * control over the overall workflow: Understand → Inspect → Plan → Execute → Verify → Recover → Complete
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_HOSTED_CAPABILITIES = exports.DEFAULT_LOCAL_CAPABILITIES = void 0;
+// ============================================================================
+// Capability Defaults
+// ============================================================================
+exports.DEFAULT_LOCAL_CAPABILITIES = {
+    canStreamEvents: true,
+    canIsolateWorkspace: false,
+    providesStructuredDiffs: false,
+    supportsSessionContinuation: true,
+    supportsCancellation: true,
+    hasInternalLoop: true,
+    supportedFileOperations: "both",
+    canRunCommands: true,
+    authMethod: "cli_session",
+};
+exports.DEFAULT_HOSTED_CAPABILITIES = {
+    canStreamEvents: true,
+    canIsolateWorkspace: false,
+    providesStructuredDiffs: false,
+    supportsSessionContinuation: true,
+    supportsCancellation: true,
+    hasInternalLoop: false,
+    supportedFileOperations: "both",
+    canRunCommands: true,
+    authMethod: "api_key",
+};