qlogicagent 2.13.4 → 2.13.5

package/dist/protocol/wire/resource-manifest.js

@@ -0,0 +1,174 @@
+export const RESOURCE_MANIFEST_SCHEMA_VERSION = 2;
+export const RUNTIME_ASSET_IDS = {
+    gatewayImage: 'gateway.image.desktop-slim',
+    whisperModelTiny: 'speech.whisper.model.tiny',
+    ffmpegWin32X64: 'runtime.ffmpeg.win32-x64',
+    nodeWin32X64: 'runtime.node.win32-x64',
+    dockerDesktopWin32X64: 'runtime.docker-desktop.win32-x64',
+    dockerDesktopDarwinX64: 'runtime.docker-desktop.darwin-x64',
+    dockerDesktopDarwinArm64: 'runtime.docker-desktop.darwin-arm64',
+};
+export const RUNTIME_PROFILE_IDS = {
+    desktopDockerBridge: 'desktop.docker-bridge',
+    desktopEmbeddedWin32X64: 'desktop.embedded.win32-x64',
+};
+function cloneAsset(asset) {
+    return {
+        ...asset,
+        artifacts: asset.artifacts.map((artifact) => ({ ...artifact })),
+    };
+}
+function cloneProfile(profile) {
+    return {
+        ...profile,
+        assetIds: [...profile.assetIds],
+    };
+}
+export function createDefaultRuntimeResourceProfiles() {
+    return {
+        [RUNTIME_PROFILE_IDS.desktopDockerBridge]: {
+            id: RUNTIME_PROFILE_IDS.desktopDockerBridge,
+            title: 'Desktop Docker Bridge',
+            platform: 'any',
+            assetIds: [
+                RUNTIME_ASSET_IDS.gatewayImage,
+                RUNTIME_ASSET_IDS.dockerDesktopWin32X64,
+                RUNTIME_ASSET_IDS.dockerDesktopDarwinX64,
+                RUNTIME_ASSET_IDS.dockerDesktopDarwinArm64,
+            ],
+            description: 'Docker bridge mode downloads the desktop slim gateway image on demand.',
+        },
+        [RUNTIME_PROFILE_IDS.desktopEmbeddedWin32X64]: {
+            id: RUNTIME_PROFILE_IDS.desktopEmbeddedWin32X64,
+            title: 'Desktop Embedded Win32 x64',
+            platform: 'win32-x64',
+            assetIds: [
+                RUNTIME_ASSET_IDS.nodeWin32X64,
+                RUNTIME_ASSET_IDS.ffmpegWin32X64,
+                RUNTIME_ASSET_IDS.whisperModelTiny,
+            ],
+            description: 'Embedded desktop mode requires the bundled Node/FFmpeg runtimes and the whisper model asset.',
+        },
+    };
+}
+export function getRuntimeResourceAsset(manifest, assetId) {
+    return manifest.assets[assetId];
+}
+export function getRuntimeResourceProfile(manifest, profileId) {
+    return manifest.profiles[profileId];
+}
+export function getRuntimeResourceProfileAssets(manifest, profileId) {
+    const profile = getRuntimeResourceProfile(manifest, profileId);
+    if (!profile)
+        return [];
+    return profile.assetIds
+        .map((assetId) => getRuntimeResourceAsset(manifest, assetId))
+        .filter((asset) => Boolean(asset));
+}
+export function upsertRuntimeResourceAsset(manifest, asset) {
+    manifest.assets[asset.id] = cloneAsset(asset);
+    return withShortcutFields(manifest);
+}
+export function getManifestShortcutEntry(asset) {
+    if (!asset)
+        return undefined;
+    const artifact = asset.artifacts[0];
+    if (!artifact?.url || !artifact.sha256 || typeof artifact.size !== 'number') {
+        return undefined;
+    }
+    return {
+        version: asset.version,
+        sha256: artifact.sha256,
+        size: artifact.size,
+        url: artifact.url,
+    };
+}
+function withShortcutFields(manifest) {
+    const gateway = getManifestShortcutEntry(manifest.assets[RUNTIME_ASSET_IDS.gatewayImage]);
+    const whisperModel = getManifestShortcutEntry(manifest.assets[RUNTIME_ASSET_IDS.whisperModelTiny]);
+    return {
+        ...manifest,
+        gateway,
+        whisperModel,
+    };
+}
+function fromFlatAsset(raw, asset) {
+    if (typeof raw.version !== 'string' || typeof raw.url !== 'string') {
+        return undefined;
+    }
+    return {
+        ...asset,
+        version: raw.version,
+        artifacts: [
+            {
+                fileName: raw.url.split('/').pop() || `${asset.id}.bin`,
+                url: raw.url,
+                sha256: typeof raw.sha256 === 'string' ? raw.sha256 : undefined,
+                size: typeof raw.size === 'number' ? raw.size : undefined,
+            },
+        ],
+    };
+}
+export function normalizeRuntimeResourceManifest(raw) {
+    const parsed = (raw && typeof raw === 'object') ? raw : {};
+    const assets = {};
+    const rawAssets = parsed.assets && typeof parsed.assets === 'object'
+        ? parsed.assets
+        : {};
+    for (const [assetId, assetValue] of Object.entries(rawAssets)) {
+        if (!assetValue || typeof assetValue !== 'object')
+            continue;
+        const asset = assetValue;
+        if (!asset.id || !Array.isArray(asset.artifacts))
+            continue;
+        assets[assetId] = cloneAsset(asset);
+    }
+    if (!assets[RUNTIME_ASSET_IDS.gatewayImage] && parsed.gateway && typeof parsed.gateway === 'object') {
+        const gatewayAsset = fromFlatAsset(parsed.gateway, {
+            id: RUNTIME_ASSET_IDS.gatewayImage,
+            title: 'OpenClaw Gateway Image (Desktop Slim)',
+            kind: 'container-image',
+            delivery: 'remote',
+            platform: 'any',
+            description: 'Desktop Docker mode gateway image.',
+        });
+        if (gatewayAsset)
+            assets[gatewayAsset.id] = gatewayAsset;
+    }
+    if (!assets[RUNTIME_ASSET_IDS.whisperModelTiny] && parsed.whisperModel && typeof parsed.whisperModel === 'object') {
+        const whisperAsset = fromFlatAsset(parsed.whisperModel, {
+            id: RUNTIME_ASSET_IDS.whisperModelTiny,
+            title: 'Whisper Tiny Model',
+            kind: 'model',
+            delivery: 'remote',
+            platform: 'any',
+            description: 'Shared whisper.cpp tiny model asset for embedded desktop speech recognition.',
+        });
+        if (whisperAsset)
+            assets[whisperAsset.id] = whisperAsset;
+    }
+    const defaultProfiles = createDefaultRuntimeResourceProfiles();
+    const profiles = { ...defaultProfiles };
+    const rawProfiles = parsed.profiles && typeof parsed.profiles === 'object'
+        ? parsed.profiles
+        : {};
+    for (const [profileId, profileValue] of Object.entries(rawProfiles)) {
+        if (!profileValue || typeof profileValue !== 'object')
+            continue;
+        const profile = profileValue;
+        if (!profile.id || !Array.isArray(profile.assetIds))
+            continue;
+        profiles[profileId] = cloneProfile(profile);
+    }
+    return withShortcutFields({
+        schemaVersion: typeof parsed.schemaVersion === 'number'
+            ? parsed.schemaVersion
+            : RESOURCE_MANIFEST_SCHEMA_VERSION,
+        channel: typeof parsed.channel === 'string' ? parsed.channel : undefined,
+        publishedAt: typeof parsed.publishedAt === 'string' ? parsed.publishedAt : undefined,
+        minElectronVersion: typeof parsed.minElectronVersion === 'string' ? parsed.minElectronVersion : undefined,
+        releaseNotes: typeof parsed.releaseNotes === 'string' ? parsed.releaseNotes : undefined,
+        assets,
+        profiles,
+    });
+}

package/dist/protocol/wire/session.d.ts

@@ -0,0 +1,32 @@
+export interface SessionIdentityContract {
+    sessionId: string;
+    sessionKey: string;
+}
+export type ModelSelectionReason = "user-selected" | "auto-default" | "failover" | "fallback" | "manual-switch";
+export interface RuntimeCapabilitySummaryContract {
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+    eligibleToolCount?: number;
+    ineligibleToolCount?: number;
+}
+export interface ApprovalRequiredToolContract {
+    toolName: string;
+    reasonCodes?: string[];
+}
+export interface RuntimeSessionContract extends SessionIdentityContract {
+    createdAt: number;
+    lastTouchedAt: number;
+    activeRunId: string | null;
+    requestedModel?: string;
+    resolvedModel?: string;
+    modelSelectionReason?: ModelSelectionReason;
+    capabilitySnapshotVersion?: string;
+    capabilitySummary?: RuntimeCapabilitySummaryContract;
+    approvalRequiredTools?: ApprovalRequiredToolContract[];
+}
+export interface PendingPromptContract extends SessionIdentityContract {
+    idempotencyKey: string;
+    sentTextLength?: number;
+    sentText?: string;
+    toolCallIds?: string[];
+}

package/dist/protocol/wire/session.js

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

package/dist/protocol/wire/thread-protocol.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Thread Protocol — Codex app-server style three-layer abstraction.
+ *
+ * Thread → Turn → Item
+ *
+ *  Thread: persistent conversation container (maps to a session)
+ *  Turn: one user request → agent response cycle
+ *  Item: individual components within a turn (message, tool_call, tool_result, etc.)
+ *
+ * This module defines the wire types. The existing `agent.turn` RPC continues
+ * to work; these types provide the foundation for `thread/*` methods.
+ */
+export type ItemType = "message" | "tool_call" | "tool_result" | "tool_blocked" | "recovery" | "plan_update" | "skill_instruction";
+export type ItemRole = "user" | "assistant" | "system";
+/** A single atomic event within a turn. */
+export interface ThreadItem {
+    /** Unique item ID. */
+    id: string;
+    /** Item type (discriminator). */
+    type: ItemType;
+    /** Role of the actor. */
+    role: ItemRole;
+    /** Text content (for message items). */
+    text?: string;
+    /** Tool name (for tool_call / tool_result items). */
+    toolName?: string;
+    /** Tool call ID (LLM-assigned). */
+    toolCallId?: string;
+    /** Serialized arguments (for tool_call). */
+    arguments?: string;
+    /** Tool output (for tool_result). */
+    output?: string;
+    /** Whether the tool was approved. */
+    approved?: boolean;
+    /** Recovery strategy used (for recovery items). */
+    strategy?: string;
+    /** Timestamp (ISO 8601). */
+    createdAt: string;
+}
+export type TurnStatus = "pending" | "in_progress" | "completed" | "failed" | "aborted";
+/** Represents one user request → agent response cycle. */
+export interface ThreadTurn {
+    /** Unique turn ID. */
+    id: string;
+    /** Thread this turn belongs to. */
+    threadId: string;
+    /** Turn status. */
+    status: TurnStatus;
+    /** Items produced during this turn. */
+    items: ThreadItem[];
+    /** Model used for this turn. */
+    model?: string;
+    /** Token usage. */
+    usage?: {
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+    };
+    /** Cost in USD. */
+    costUSD?: number;
+    /** Turn creation time. */
+    createdAt: string;
+    /** Turn completion time. */
+    completedAt?: string;
+}
+export type ThreadStatus = "active" | "archived" | "deleted";
+/** Persistent conversation container. */
+export interface Thread {
+    /** Unique thread ID (maps to session ID). */
+    id: string;
+    /** Display title (auto-generated or user-set). */
+    title?: string;
+    /** Thread status. */
+    status: ThreadStatus;
+    /** All turns in this thread. */
+    turns: ThreadTurn[];
+    /** Working directory. */
+    cwd?: string;
+    /** Thread creation time. */
+    createdAt: string;
+    /** Last activity time. */
+    lastActiveAt: string;
+}
+/**
+ * `initialize` request params — superset of agent.hello.
+ * Sent by host as the first message after transport connects.
+ */
+export interface InitializeParams {
+    /** Protocol version. */
+    protocolVersion: string;
+    /** Host application info. */
+    host: {
+        name: string;
+        version: string;
+    };
+    /** Host capabilities. */
+    capabilities?: {
+        /** Host can receive streaming deltas. */
+        streaming?: boolean;
+        /** Host supports tool approval flow. */
+        toolApproval?: boolean;
+        /** Host supports thread persistence. */
+        threads?: boolean;
+    };
+    /** Optional initial configuration. */
+    config?: Record<string, unknown>;
+}
+/** `initialize` response result. */
+export interface InitializeResult {
+    /** Agent protocol version. */
+    protocolVersion: string;
+    /** Agent info. */
+    agent: {
+        name: string;
+        version: string;
+    };
+    /** Agent capabilities. */
+    capabilities: {
+        tools: string[];
+        streaming: boolean;
+        threads: boolean;
+    };
+}
+/** `thread/create` params. */
+export interface ThreadCreateParams {
+    /** Optional thread ID (auto-generated if not provided). */
+    id?: string;
+    /** Optional title. */
+    title?: string;
+    /** Working directory. */
+    cwd?: string;
+    /** LLM configuration. */
+    config?: Record<string, unknown>;
+}
+/** `thread/list` result. */
+export interface ThreadListResult {
+    threads: Array<{
+        id: string;
+        title?: string;
+        status: ThreadStatus;
+        turnCount: number;
+        createdAt: string;
+        lastActiveAt: string;
+    }>;
+}

package/dist/protocol/wire/thread-protocol.js

@@ -0,0 +1,13 @@
+/**
+ * Thread Protocol — Codex app-server style three-layer abstraction.
+ *
+ * Thread → Turn → Item
+ *
+ *  Thread: persistent conversation container (maps to a session)
+ *  Turn: one user request → agent response cycle
+ *  Item: individual components within a turn (message, tool_call, tool_result, etc.)
+ *
+ * This module defines the wire types. The existing `agent.turn` RPC continues
+ * to work; these types provide the foundation for `thread/*` methods.
+ */
+export {};

package/dist/protocol/wire/transport.d.ts

@@ -0,0 +1,57 @@
+export type ProxyLocale = "cn" | "intl";
+export type ProxyKeySource = "managed" | "user";
+export type ProxyQuotaSource = "subscription" | "topup" | "free" | "own-key";
+export type ProxyRequestCategory = "text" | "image" | "video" | "music" | "audio" | "vision";
+export interface TransportUsageInfo {
+    input: number;
+    output: number;
+    cacheRead?: number;
+}
+export interface TransportResponsePayload {
+    statusCode: number;
+    body: string;
+    usage?: TransportUsageInfo;
+}
+export interface TransportResponseMsg {
+    type: "proxy.response";
+    id: string;
+    payload: TransportResponsePayload;
+}
+export interface TransportErrorPayload {
+    error: string;
+    code: string;
+    retryable: boolean;
+}
+export interface TransportErrorMsg {
+    type: "proxy.error";
+    id: string;
+    payload: TransportErrorPayload;
+}
+export interface TransportBillingInfo {
+    premiumCost: number;
+    tier: string;
+    provider: string;
+    model: string;
+    requestCategory?: ProxyRequestCategory;
+    quotaSource?: ProxyQuotaSource;
+    keySource?: ProxyKeySource;
+}
+export interface AgentExecutionRefs {
+    executionId?: string;
+    rootExecutionId?: string;
+    parentExecutionId?: string;
+    sidechainId?: string;
+    attemptId?: string;
+    outcomeId?: string;
+}
+export type AgentExecutionSource = "turn" | "resume" | "replay" | "sidechain";
+export type AgentAttemptSource = "primary" | "retry" | "fallback" | "repair";
+export type AgentSidechainType = "research" | "planner" | "plan-repair" | "code-repair" | "media-prep" | "custom";
+export type AgentSidechainRole = "leaf" | "orchestrator";
+export type AgentSidechainMergePolicy = "summary-only" | "append-messages" | "replace-context" | "manual";
+export type AgentExecutionSessionStatus = "running" | "interrupted" | "completed" | "failed" | "cancelled";
+export type ControlApprovalDecision = "approved" | "denied" | "expired" | "cancelled";
+export type ControlApprovalSource = "user" | "policy" | "system" | "replay";
+export type ExecutionInterruptReason = "approval-wait" | "gateway-disconnected" | "policy-pause" | "user-pause" | "tool-backpressure" | "lease-expired";
+export type ExecutionResumeSource = "user" | "gateway-reconnect" | "policy" | "system";
+export type ExecutionCancelReason = "user-cancel" | "policy-cancel" | "lease-expired" | "superseded" | "branch-cancel";

package/dist/protocol/wire/transport.js

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

package/dist/protocol/wire/turn.d.ts

@@ -0,0 +1,208 @@
+import type { AgentExecutionRefs, TransportResponsePayload, TransportUsageInfo, TransportBillingInfo } from "./transport.js";
+import type { ModelSelectionReason } from "./session.js";
+import type { TransportCapabilitySummaryContract, TransportApprovalRequiredToolHintEntry, TransportToolEligibilitySummaryEntry, ToolExecutionStepContext, ToolInvokeApprovalDescriptor, AgentTurnConversation, AgentTurnExperience, AgentTurnRequestSpec, AgentTurnLocalContext, AgentTurnClientHints } from "./capability-transport.js";
+export interface AgentTurnStartPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    deviceId?: string;
+    principalId?: string;
+    entitlementId?: string;
+    subscriptionKey?: string;
+    conversation: AgentTurnConversation;
+    experience?: AgentTurnExperience;
+    request?: AgentTurnRequestSpec;
+    localContext?: AgentTurnLocalContext;
+    clientHints?: AgentTurnClientHints;
+}
+export interface AgentTurnStartMsg extends AgentTurnStartPayload {
+    type: "agent.turn.start";
+    id: string;
+}
+export interface AgentTurnThinkingPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    stage?: "routing" | "execution" | "tool-wait";
+    message?: string;
+}
+export interface AgentTurnThinkingMsg {
+    type: "agent.turn.thinking";
+    id: string;
+    payload: AgentTurnThinkingPayload;
+}
+export interface AgentTurnDeltaPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    chunk: string;
+}
+export interface AgentTurnDeltaMsg {
+    type: "agent.turn.delta";
+    id: string;
+    payload: AgentTurnDeltaPayload;
+}
+export interface AgentTurnToolPlannedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    approvalMode?: "user-confirm" | "pre-authorized";
+}
+export interface AgentTurnToolPlannedMsg {
+    type: "agent.turn.tool-planned";
+    id: string;
+    payload: AgentTurnToolPlannedPayload;
+}
+export interface AgentTurnToolRunningPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+}
+export interface AgentTurnToolRunningMsg {
+    type: "agent.turn.tool-running";
+    id: string;
+    payload: AgentTurnToolRunningPayload;
+}
+export interface AgentTurnCompletedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    outcomeId: string;
+    resolvedModel?: string;
+    modelSelectionReason?: ModelSelectionReason;
+    capabilitySummary?: TransportCapabilitySummaryContract;
+    approvalRequiredToolHint?: TransportApprovalRequiredToolHintEntry[];
+    eligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    ineligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    response?: TransportResponsePayload;
+    usage?: TransportUsageInfo;
+    billed?: TransportBillingInfo | null;
+}
+export interface AgentTurnCompletedMsg {
+    type: "agent.turn.completed";
+    id: string;
+    payload: AgentTurnCompletedPayload;
+}
+export interface BillingRecordedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    outcomeId: string;
+    billed: TransportBillingInfo;
+}
+export interface BillingRecordedMsg {
+    type: "billing.recorded";
+    id: string;
+    payload: BillingRecordedPayload;
+}
+export interface AgentTurnFailedPayload extends AgentExecutionRefs {
+    sessionId: string;
+    turnId: string;
+    outcomeId: string;
+    code: string;
+    error: string;
+    retryable: boolean;
+}
+export interface AgentTurnFailedMsg {
+    type: "agent.turn.failed";
+    id: string;
+    payload: AgentTurnFailedPayload;
+}
+export interface ToolInvokePlannedPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+    arguments?: Record<string, unknown>;
+    approvalMode?: "user-confirm" | "pre-authorized";
+}
+export interface ToolInvokePlannedMsg {
+    type: "tool.invoke.planned";
+    id: string;
+    payload: ToolInvokePlannedPayload;
+}
+export interface ToolInvokeStartedPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    toolName: string;
+}
+export interface ToolInvokeStartedMsg {
+    type: "tool.invoke.started";
+    id: string;
+    payload: ToolInvokeStartedPayload;
+}
+export interface ToolInvokeRequestPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    tool: {
+        name: string;
+        arguments: Record<string, unknown>;
+    };
+    approval?: ToolInvokeApprovalDescriptor;
+}
+export interface ToolInvokeRequestMsg {
+    type: "tool.invoke.request";
+    id: string;
+    payload: ToolInvokeRequestPayload;
+}
+export interface ToolInvokeResultPayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId: string;
+    callId: string;
+    outcomeId: string;
+    ok: boolean;
+    payload?: unknown;
+    error?: string;
+}
+export interface ToolInvokeResultMsg {
+    type: "tool.invoke.result";
+    id: string;
+    payload: ToolInvokeResultPayload;
+}
+export type LocalExecutionEnvelopeKind = "started" | "partial" | "checkpoint" | "artifact" | "final" | "error";
+export type LocalExecutionEnvelopeStage = "turn" | "tool" | "checkpoint" | "artifact" | "control" | "memory";
+export interface LocalExecutionEnvelopePayload extends AgentExecutionRefs, ToolExecutionStepContext {
+    sessionId: string;
+    turnId?: string;
+    kind: LocalExecutionEnvelopeKind;
+    stage: LocalExecutionEnvelopeStage;
+    eventType: string;
+    emittedAtMs: number;
+    callId?: string;
+    approvalId?: string;
+    checkpointId?: string;
+    restoreId?: string;
+    summary?: string;
+    data?: Record<string, unknown>;
+}
+export interface LocalExecutionEnvelopeMsg {
+    type: "local.execution.envelope";
+    id: string;
+    payload: LocalExecutionEnvelopePayload;
+}
+export interface AgentSkillCreatePayload {
+    sessionId: string;
+    turnId: string;
+    executionId?: string;
+    suggestedName: string;
+    description: string;
+    tools: string[];
+    stepCount: number;
+}
+export interface AgentSkillCreateMsg {
+    type: "agent.skill.create";
+    id: string;
+    payload: AgentSkillCreatePayload;
+}
+export interface AgentSkillImprovePayload {
+    sessionId: string;
+    turnId: string;
+    executionId?: string;
+    skillName: string;
+    reason: string;
+}
+export interface AgentSkillImproveMsg {
+    type: "agent.skill.improve";
+    id: string;
+    payload: AgentSkillImprovePayload;
+}

package/dist/protocol/wire/turn.js

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