qlogicagent 2.10.21 → 2.10.23

package/dist/types/runtime/ports/agent-execution-contracts.d.ts

@@ -0,0 +1,182 @@
+import type { HookRegistry } from "../../contracts/hooks.js";
+import type { ChatMessage as WireChatMessage, ToolDefinition as WireToolDefinition, WireTokenUsage } from "../../protocol/wire/index.js";
+export type ChatMessage = WireChatMessage;
+export type TokenUsage = WireTokenUsage;
+export interface ToolDefinition extends WireToolDefinition {
+    backfillObservableInput?: (input: Record<string, unknown>) => void;
+}
+export type TurnEvent = {
+    type: "start";
+    turnId: string;
+} | {
+    type: "delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "tool_call";
+    turnId: string;
+    callId: string;
+    name: string;
+    arguments: string;
+    inputSummary?: string;
+} | {
+    type: "end";
+    turnId: string;
+    content: string;
+    usage?: TokenUsage;
+    model?: string;
+    provider?: string;
+} | {
+    type: "error";
+    turnId: string;
+    error: string;
+    code?: string;
+    usage?: TokenUsage;
+} | {
+    type: "skill_instruction";
+    turnId: string;
+    instruction: unknown;
+} | {
+    type: "tool_result";
+    turnId: string;
+    callId: string;
+    name: string;
+    ok: boolean;
+    error?: string;
+    outputPreview?: string;
+    durationMs?: number;
+    exitCode?: number;
+    stdout?: string;
+    stderr?: string;
+    details?: Record<string, unknown>;
+} | {
+    type: "tool_blocked";
+    turnId: string;
+    callId: string;
+    name: string;
+    reason: string;
+} | {
+    type: "recovery";
+    turnId: string;
+    action: string;
+    detail?: string;
+} | {
+    type: "plan_update";
+    turnId: string;
+    slug: string;
+    content: string;
+} | {
+    type: "heartbeat";
+    turnId: string;
+    message: string;
+} | {
+    type: "tool_use_summary";
+    turnId: string;
+    summary: string;
+} | {
+    type: "reasoning_delta";
+    turnId: string;
+    text: string;
+} | {
+    type: "suggestions";
+    turnId: string;
+    items: Array<{
+        text: string;
+        icon?: string;
+        action?: string;
+    }>;
+} | {
+    type: "media_result";
+    turnId: string;
+    mediaType: "image" | "tts" | "video" | "music";
+    url: string;
+    model?: string;
+    provider?: string;
+    durationSeconds?: number;
+    width?: number;
+    height?: number;
+    mimeType?: string;
+    billingUnit?: string;
+    billingQuantity?: number;
+    taskId?: string;
+} | {
+    type: "artifact";
+    turnId: string;
+    artifactId: string;
+    artifactType: "code" | "file" | "image" | "document" | "diagram" | "table";
+    title: string;
+    filePath?: string;
+    language?: string;
+    content?: string;
+    mimeType?: string;
+} | {
+    type: "annotations";
+    turnId: string;
+    annotations: Array<{
+        type: string;
+        url?: string;
+        title?: string;
+        [key: string]: unknown;
+    }>;
+} | {
+    type: "subagent_started";
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    prompt?: string;
+} | {
+    type: "subagent_ended";
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    ok: boolean;
+    outputPreview?: string;
+    error?: string;
+};
+export interface ToolInvoker {
+    invoke(turnId: string, name: string, args: string, signal?: AbortSignal): Promise<{
+        result: string;
+        error?: string;
+        toolReferences?: string[];
+        imageUrls?: string[];
+        details?: Record<string, unknown>;
+    }>;
+}
+export interface AgentRunRequest {
+    turnId: string;
+    sessionId: string;
+    messages: ChatMessage[];
+    tools: ToolDefinition[];
+    systemPrompt?: string;
+    config?: {
+        model?: string;
+        apiKey?: string;
+        temperature?: number;
+        maxOutputTokens?: number;
+        parentDepth?: number;
+    };
+}
+export interface ForkedAgentRunner {
+    run(request: AgentRunRequest, signal?: AbortSignal): AsyncIterable<TurnEvent>;
+}
+export interface ForkedAgentRunnerFactory {
+    (params: {
+        transport: unknown;
+        apiKey: string;
+        toolInvoker: ToolInvoker;
+        log: AgentLogger;
+        hooks?: HookRegistry;
+        maxRounds?: number;
+    }): ForkedAgentRunner;
+}
+export interface AgentLogger {
+    info(message: string): void;
+    info(obj: Record<string, unknown>, message: string): void;
+    warn(message: string): void;
+    warn(obj: Record<string, unknown>, message: string): void;
+    error(message: string): void;
+    error(obj: Record<string, unknown>, message: string): void;
+    debug(message: string): void;
+    debug(obj: Record<string, unknown>, message: string): void;
+}
+export type { HookRegistry };

package/dist/types/runtime/ports/checkpoint-contracts.d.ts

@@ -0,0 +1,19 @@
+export interface Checkpoint {
+    id: string;
+    message: string;
+    timestamp: string;
+    fileCount: number;
+}
+export interface CheckpointResult {
+    success: boolean;
+    checkpoint?: Checkpoint;
+    checkpoints?: Checkpoint[];
+    diff?: string;
+    error?: string;
+}
+export interface CheckpointBackend {
+    createCheckpoint(message?: string): Promise<CheckpointResult>;
+    listCheckpoints(): Promise<CheckpointResult>;
+    restoreCheckpoint(checkpointId: string, paths?: string[]): Promise<CheckpointResult>;
+    diffCheckpoint(checkpointId: string): Promise<CheckpointResult>;
+}

package/dist/types/runtime/ports/index.d.ts

@@ -0,0 +1,13 @@
+export type { MemoryWriter, MemoryWriteMetadata } from "./memory-writer.js";
+export type { MemoryRecallSource } from "./memory-recall-source.js";
+export type { MemoryProvider, MemorySearchOptions, MemorySearchResult, MemoryIngestMessage, MemoryIngestOptions, MemoryExtractionItem, MemoryConsolidationWriteResult, MemoryLearningSink, MemoryToolLocalProvider, MemoryActivitySummary, MemoryAtlasRecord, MemoryAtlasResult, MemoryUpdatePatch, MemoryHandlerProvider, MemoryDreamProvider, MemoryDecayProvider, MemoryRuntimeHookProvider, MemoryToolProvider, MemoryDreamRuntimeProvider, } from "./memory-provider.js";
+export type { PathService } from "./path-service.js";
+export { PERMISSION_MODES, } from "./permission-contracts.js";
+export type { ApprovalRequest, ApprovalResponse, PermissionApprovalResolver, PermissionBehavior, PermissionConfig, PermissionDecisionReason, PermissionMetadataResolver, PermissionMode, PermissionResult, PermissionRuleEnginePort, PermissionRuleEntry, PermissionUpdate, ToolPermissionCheckInput, } from "./permission-contracts.js";
+export type { ProjectMemoryFileInfo, ProjectMemoryResult, ProjectMemoryStore, ProjectMemoryStoreFactory, } from "./project-memory-store.js";
+export type { ToolBootstrap, ToolCatalog } from "./tool-contracts.js";
+export type { Checkpoint, CheckpointBackend, CheckpointResult } from "./checkpoint-contracts.js";
+export type { WorktreeBackend, WorktreeInfo, WorktreeResult } from "./worktree-contracts.js";
+export type { WebSearchBackend, WebSearchOutput, WebSearchResult } from "./web-search-contracts.js";
+export { buildToolResultMessage, type OpenAiToolCall, type ToolResultMessageInput } from "./tool-call-contracts.js";
+export type { AgentLogger, AgentRunRequest, ChatMessage, ForkedAgentRunner, ForkedAgentRunnerFactory, HookRegistry, TokenUsage, ToolDefinition, ToolInvoker, TurnEvent, } from "./agent-execution-contracts.js";

package/dist/types/runtime/ports/memory-provider.d.ts

@@ -0,0 +1,146 @@
+import type { MemoryWriter } from "./memory-writer.js";
+export interface MemorySearchOptions {
+    limit?: number;
+    minScore?: number;
+    preferredCategories?: string[];
+    llmConfig?: unknown;
+}
+export interface MemorySearchResult {
+    blockId: string;
+    id?: string;
+    path?: string;
+    text: string;
+    content?: string;
+    score: number;
+    source?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface MemoryIngestMessage {
+    role: string;
+    content: string;
+    timestamp?: number;
+}
+export interface MemoryIngestOptions {
+    llmConfig?: unknown;
+    source?: string;
+    sessionId?: string;
+}
+export interface MemoryExtractionItem {
+    text: string;
+    category?: string;
+    importance?: number;
+    confidence?: number;
+    source?: string;
+    event_date?: string;
+    tags?: string[];
+}
+export interface MemoryConsolidationWriteResult {
+    memoriesAdded?: number;
+    observationsAdded?: number;
+    proposalsAdded?: number;
+    claimsAdded?: number;
+    conflictsAdded?: number;
+    claimIds?: string[];
+    conflictIds?: string[];
+}
+export interface MemoryProvider {
+    readonly providerId: string;
+    search(query: string, userId: string, options?: MemorySearchOptions): Promise<MemorySearchResult[]>;
+    ingest?(messages: MemoryIngestMessage[], userId: string, options?: MemoryIngestOptions): Promise<void>;
+    addText?(text: string, userId: string, options?: MemoryIngestOptions): Promise<{
+        memoriesAdded: number;
+    }>;
+    remove?(memoryId: string): Promise<boolean>;
+}
+export interface MemoryLearningSink {
+    ingestExtracted(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
+}
+export interface MemoryToolLocalProvider {
+    addText(text: string, userId: string, metadata?: MemoryIngestOptions & {
+        category?: string;
+        importance?: number;
+    }): Promise<unknown>;
+    synthesizeTimeline(userId: string, startMs: number, endMs: number): string;
+    feedback(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
+        affected: number;
+    }>;
+}
+export interface MemoryActivitySummary {
+    dailyCounts: Array<{
+        date: string;
+        count: number;
+    }>;
+    highlights: Array<{
+        text: string;
+        category: string;
+        importance: number;
+        date: string;
+    }>;
+}
+export interface MemoryAtlasRecord {
+    id: string;
+    text: string;
+    category?: string;
+    importance?: number;
+    confidence?: number;
+    source?: string;
+    sessionId?: string;
+    eventDate?: string;
+    tags?: string[];
+    createdAt?: string | number;
+    updatedAt?: string | number;
+    accessCount?: number;
+    lastAccessedAt?: string | number;
+    isArchived?: boolean;
+}
+export interface MemoryAtlasResult {
+    totalCount?: number;
+    records?: MemoryAtlasRecord[];
+    buckets?: unknown[];
+    clusters?: unknown[];
+    windowCursor?: unknown;
+    timeRange?: unknown;
+}
+export interface MemoryUpdatePatch {
+    text?: string;
+    category?: string;
+    importance?: number;
+    source?: string;
+    eventDate?: string;
+    tags?: string[];
+}
+export interface MemoryHandlerProvider extends MemoryProvider {
+    getAtlas?(userId: string, options?: Record<string, unknown>): MemoryAtlasResult;
+    getActivitySummary?(userId: string, days: number): MemoryActivitySummary;
+    observeExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
+    proposeExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
+    ingestExtracted?(items: MemoryExtractionItem[], userId: string, options?: MemoryIngestOptions): Promise<MemoryConsolidationWriteResult>;
+    update?(id: string, patch: MemoryUpdatePatch): Promise<boolean>;
+}
+export interface MemoryDreamProvider {
+    search(query: string, userId: string, options?: {
+        limit?: number;
+    }): Promise<MemorySearchResult[]>;
+    proposeExtracted?(items: MemoryExtractionItem[], userId: string, options?: {
+        sessionId?: string;
+        source?: string;
+    }): Promise<{
+        proposalsAdded?: number;
+    }>;
+    feedback?(memoryIds: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<{
+        affected: number;
+    }>;
+    getActivitySummary?(userId: string, days?: number): MemoryActivitySummary;
+    synthesizeTimeline?(userId: string, startMs: number, endMs: number): string;
+    getProfile?(userId: string, key: string): string | null;
+    setProfile?(userId: string, key: string, value: string): void;
+    getAllProfiles?(userId: string): Record<string, string>;
+}
+export interface MemoryDecayProvider {
+    triggerDecay(userId: string, maxAgeDays?: number): Promise<{
+        decayed: number;
+    }>;
+}
+export type MemoryRuntimeHookProvider = MemoryProvider & MemoryWriter;
+export type MemoryToolProvider = MemoryProvider & MemoryToolLocalProvider;
+export type MemoryDreamRuntimeProvider = MemoryDreamProvider & MemoryDecayProvider;

package/dist/types/runtime/ports/memory-recall-source.d.ts

@@ -0,0 +1,3 @@
+export interface MemoryRecallSource {
+    getRootPath(): string;
+}

package/dist/types/runtime/ports/memory-writer.d.ts

@@ -0,0 +1,21 @@
+export interface MemoryWriteMetadata {
+    source?: string;
+    category?: string;
+    importance?: number;
+    eventDate?: string;
+    [key: string]: unknown;
+}
+export interface MemoryWriter {
+    addText(text: string, userId: string, metadata?: MemoryWriteMetadata): Promise<unknown>;
+    proposeExtracted?(items: Array<{
+        text: string;
+        category?: string;
+        importance?: number;
+    }>, userId: string, metadata?: MemoryWriteMetadata): Promise<{
+        proposalsAdded?: number;
+    }>;
+    findRelatedEvents?(text: string, userId: string): Promise<Array<{
+        id: string;
+    }>>;
+    feedback?(ids: string[], signal: "useful" | "irrelevant" | "outdated" | "wrong"): Promise<unknown>;
+}

package/dist/types/runtime/ports/path-service.d.ts

@@ -0,0 +1,5 @@
+export interface PathService {
+    getActiveProjectRoot(): string;
+    setActiveWorkdir(dir: string): void;
+    resolveProjectDir(projectId?: string): string | undefined;
+}

package/dist/types/runtime/ports/permission-contracts.d.ts

@@ -0,0 +1,107 @@
+export type PermissionMode = "default" | "bypassPermissions" | "acceptEdits" | "dontAsk" | "plan" | "auto";
+export declare const PERMISSION_MODES: readonly PermissionMode[];
+export type PermissionBehavior = "allow" | "deny" | "ask";
+export interface PermissionRuleEntry {
+    pattern: string;
+    behavior: PermissionBehavior;
+    reason?: string;
+    source?: string;
+}
+export type PermissionDecisionReason = {
+    type: "rule";
+    rule: PermissionRuleEntry;
+} | {
+    type: "mode";
+    mode: PermissionMode;
+} | {
+    type: "hook";
+    hookName: string;
+    reason: string;
+} | {
+    type: "classifier";
+    classifier: string;
+    reason: string;
+} | {
+    type: "tool_check";
+    reason: string;
+} | {
+    type: "eligibility";
+    reasonCodes: string[];
+} | {
+    type: "sandbox";
+    reason: string;
+} | {
+    type: "other";
+    reason: string;
+};
+export interface PermissionAllowResult {
+    behavior: "allow";
+    updatedInput?: Record<string, unknown>;
+    decisionReason?: PermissionDecisionReason;
+}
+export interface PermissionAskResult {
+    behavior: "ask";
+    message: string;
+    toolName: string;
+    input?: Record<string, unknown>;
+    suggestions?: PermissionUpdate[];
+    decisionReason?: PermissionDecisionReason;
+}
+export interface PermissionDenyResult {
+    behavior: "deny";
+    message: string;
+    decisionReason: PermissionDecisionReason;
+}
+export type PermissionResult = PermissionAllowResult | PermissionAskResult | PermissionDenyResult;
+export interface PermissionUpdate {
+    pattern: string;
+    behavior: PermissionBehavior;
+    scope?: "session" | "persistent";
+    description?: string;
+}
+export interface PermissionConfig {
+    mode: PermissionMode;
+    rules: PermissionRuleEntry[];
+    defaultBehavior: PermissionBehavior;
+}
+export interface ToolPermissionCheckInput {
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    meta?: {
+        isReadOnly?: boolean;
+        isDangerous?: boolean;
+        requiresApproval?: boolean;
+        parallelSafe?: boolean;
+    };
+}
+export interface ApprovalRequest {
+    approvalId: string;
+    callId: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    message: string;
+    suggestions?: PermissionUpdate[];
+}
+export interface ApprovalResponse {
+    approvalId: string;
+    decision: "approved" | "denied";
+    updatedInput?: Record<string, unknown>;
+    permissionUpdate?: PermissionUpdate;
+}
+export interface PermissionRuleEnginePort {
+    setMode(mode: PermissionMode): void;
+    replaceRules(rules: PermissionRuleEntry[]): void;
+    setDefaultBehavior(behavior: PermissionBehavior): void;
+}
+export interface PermissionApprovalResolver {
+    resolveApproval(response: ApprovalResponse): void;
+}
+export interface PermissionMetadataResolver extends PermissionApprovalResolver {
+    setToolMeta?(tools: Array<{
+        function: {
+            name: string;
+        };
+        meta?: ToolPermissionCheckInput["meta"];
+    }>): void;
+    ruleEngineRef?: PermissionRuleEnginePort;
+}

package/dist/types/runtime/ports/project-memory-store.d.ts

@@ -0,0 +1,44 @@
+export interface ProjectMemoryFileInfo {
+    name: string;
+    size: number;
+    modifiedAt: string;
+    preview?: string;
+}
+export interface ProjectMemoryResult {
+    ok: boolean;
+    message: string;
+    file?: string;
+    indexUsage?: string;
+}
+export interface ProjectMemoryStore {
+    getRootPath(): string;
+    ensureInitialized(): void;
+    getIndexForPrompt(): string;
+    getIndexRaw(): string;
+    getIndexUsage(): {
+        chars: number;
+        lines: number;
+        percent: number;
+    };
+    addToIndex(content: string): Promise<ProjectMemoryResult>;
+    replaceInIndex(oldText: string, newText: string): Promise<ProjectMemoryResult>;
+    removeFromIndex(oldText: string): Promise<ProjectMemoryResult>;
+    createFile(name: string, content: string): Promise<ProjectMemoryResult>;
+    writeFile(name: string, content: string): Promise<ProjectMemoryResult>;
+    readFile(name: string): Promise<{
+        ok: boolean;
+        content?: string;
+        message: string;
+    }>;
+    deleteFile(name: string): Promise<ProjectMemoryResult>;
+    listFiles(): Promise<ProjectMemoryFileInfo[]>;
+    searchLocal(query: string): Promise<Array<{
+        file: string;
+        snippet: string;
+        score: number;
+    }>>;
+}
+export interface ProjectMemoryStoreFactory {
+    getRootPath(projectRoot: string): string;
+    create(projectRoot: string): ProjectMemoryStore;
+}

package/dist/types/runtime/ports/tool-call-contracts.d.ts

@@ -0,0 +1,16 @@
+export interface OpenAiToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ToolResultMessageInput {
+    ok: boolean;
+    payload?: unknown;
+    error?: string;
+    toolReferences?: string[];
+    imageUrls?: string[];
+}
+export declare function buildToolResultMessage(callId: string, result: ToolResultMessageInput): Record<string, unknown>;

package/dist/types/runtime/ports/tool-contracts.d.ts

@@ -0,0 +1,23 @@
+import type { ToolDefinition } from "../../protocol/wire/index.js";
+export interface RuntimeToolContract {
+    name: string;
+    label: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    isEnabled?: () => boolean;
+    shouldDefer?: boolean;
+    execute?(toolCallId: string, params: Record<string, unknown>, signal?: AbortSignal): Promise<{
+        content: Array<{
+            text?: string;
+        }>;
+    }>;
+}
+export interface ToolCatalog {
+    findTool(name: string): RuntimeToolContract | undefined;
+    getToolManifest(includeDeferred?: boolean): ToolDefinition[];
+    getToolNames(): string[];
+}
+export interface ToolBootstrap {
+    getAllBaseTools(): RuntimeToolContract[];
+    setWorkdir(dir: string): void;
+}

package/dist/types/runtime/ports/web-search-contracts.d.ts

@@ -0,0 +1,17 @@
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+}
+export interface WebSearchOutput {
+    query: string;
+    results: WebSearchResult[];
+    totalResults?: number;
+}
+export interface WebSearchBackend {
+    search(query: string, options?: {
+        allowedDomains?: string[];
+        blockedDomains?: string[];
+        maxResults?: number;
+    }): Promise<WebSearchOutput>;
+}

package/dist/types/runtime/ports/worktree-contracts.d.ts

@@ -0,0 +1,22 @@
+export interface WorktreeInfo {
+    name: string;
+    path: string;
+    branch: string;
+    isCurrent: boolean;
+    hasChanges: boolean;
+    unpushedCommits: number;
+}
+export interface WorktreeResult {
+    success: boolean;
+    worktree?: WorktreeInfo;
+    worktrees?: WorktreeInfo[];
+    previousCwd?: string;
+    error?: string;
+}
+export interface WorktreeBackend {
+    enterWorktree(name?: string): Promise<WorktreeResult>;
+    exitWorktree(action: "keep" | "remove", discardChanges?: boolean): Promise<WorktreeResult>;
+    listWorktrees(): Promise<WorktreeResult>;
+    isInWorktree(): boolean;
+    currentWorktree?(): WorktreeInfo | null;
+}

package/dist/types/runtime/prompt/environment-context.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/runtime/prompt/fresh-workspace-evidence.d.ts

@@ -0,0 +1,19 @@
+import { type SystemPromptSection } from "./system-prompt-sections.js";
+export interface PromptMessageLike {
+    role?: string;
+    content?: unknown;
+}
+export interface ToolNameLike {
+    function?: {
+        name?: string;
+    };
+    name?: string;
+}
+export interface FreshWorkspaceEvidencePolicy {
+    requiresFreshTool: boolean;
+    reason?: "file-read" | "file-mutation" | "memory-mutation" | "directory-list" | "content-search" | "shell" | "web";
+    allowedToolNames: string[];
+}
+export declare function getFreshWorkspaceEvidencePolicy(messages: readonly PromptMessageLike[] | string): FreshWorkspaceEvidencePolicy;
+export declare function selectFreshWorkspaceEvidenceTools<TTool extends ToolNameLike>(tools: readonly TTool[], policy: FreshWorkspaceEvidencePolicy): TTool[];
+export declare function createFreshWorkspaceEvidenceSection(policy: FreshWorkspaceEvidencePolicy): SystemPromptSection | null;

package/dist/types/runtime/prompt/fresh-workspace-evidence.test.d.ts

@@ -0,0 +1 @@
+export {};