qlogicagent 2.13.4 → 2.13.5

package/dist/protocol/wire/agent-rpc.js

@@ -0,0 +1,72 @@
+// ============================================================
+// Agent JSON-RPC 2.0 protocol — shared wire types between
+// agent CLI subprocess and host (Gateway / Hub).
+// ============================================================
+/**
+ * Protocol version. Both sides exchange this during `agent.hello`
+ * handshake. If major versions differ the host MUST reject.
+ */
+export const AGENT_RPC_PROTOCOL_VERSION = "1.0.0";
+// ── Error codes (JSON-RPC 2.0 §5.1 + agent-specific) ────────────────────────
+export const AGENT_RPC_ERROR_CODES = {
+    // JSON-RPC 2.0 standard
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603,
+    // Agent-specific (application range: -32000 to -32099)
+    TURN_ABORTED: -32000,
+    TURN_TIMEOUT: -32001,
+    LLM_ERROR: -32010,
+    LLM_AUTH_ERROR: -32011,
+    LLM_RATE_LIMIT: -32012,
+    LLM_QUOTA_EXHAUSTED: -32013,
+    LLM_MODEL_NOT_FOUND: -32014,
+    TOOL_INVOKE_FAILED: -32020,
+    TOOL_TIMEOUT: -32021,
+    PROTOCOL_MISMATCH: -32030,
+    REQUEST_DEADLINE_EXCEEDED: -32040,
+    REQUEST_CANCELLED: -32041,
+    REQUEST_DEDUPED: -32042,
+    REQUEST_IDEMPOTENCY_REQUIRED: -32043,
+};
+/** Well-known method names for the approval protocol. */
+export const AGENT_RPC_APPROVAL_METHODS = {
+    REQUEST: "tool.approval.request",
+};
+// ── Runtime guards ───────────────────────────────────────────────────────────
+export function isAgentRpcRequest(msg) {
+    if (!msg || typeof msg !== "object")
+        return false;
+    const m = msg;
+    return m.jsonrpc === "2.0" && typeof m.method === "string" && m.method.length > 0;
+}
+export function isAgentRpcResponse(msg) {
+    if (!msg || typeof msg !== "object")
+        return false;
+    const m = msg;
+    return m.jsonrpc === "2.0" && (typeof m.id === "string" || typeof m.id === "number") && !("method" in m);
+}
+export function isAgentRpcNotification(msg) {
+    if (!msg || typeof msg !== "object")
+        return false;
+    const m = msg;
+    return m.jsonrpc === "2.0" && typeof m.method === "string" && !("id" in m);
+}
+export function parseAgentRpcMessage(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (isAgentRpcResponse(parsed))
+        return parsed;
+    if (isAgentRpcRequest(parsed))
+        return parsed;
+    if (isAgentRpcNotification(parsed))
+        return parsed;
+    return null;
+}

package/dist/protocol/wire/capability-manifest.d.ts

@@ -0,0 +1,112 @@
+import type { WebActionScope, WebApprovalDefault, WebCapabilityDescriptorContract, WebCapabilityFamily, WebCapabilityId, WebDegradationTarget, WebEscalationReason, WebExecutionMode, WebPolicyRiskClass, WebRetryPolicy, WebStatefulness, WebTaskMode, ToolRiskLevel } from "./web-capability.js";
+import type { ApprovalRequiredToolContract } from "./session.js";
+export declare const CAPABILITY_MANIFEST_DIFF_SECTIONS: readonly ["gatewayVersion", "toolNamespaces", "workspaceIds", "installedCapabilities", "enabledCapabilities", "features", "approvalMode", "toolManifests", "skillManifests", "pluginManifests", "mcpManifests", "approvalPolicy", "workspaceSummaries"];
+export type CapabilityManifestDiffSection = (typeof CAPABILITY_MANIFEST_DIFF_SECTIONS)[number];
+export type CapabilityManifestApprovalMode = "user-confirm" | "pre-authorized";
+export type CapabilityToolManifestContract = WebCapabilityDescriptorContract & {
+    name: string;
+    label: string;
+    description: string;
+    source: "core" | "plugin";
+    capabilityId?: WebCapabilityId;
+    capabilityFamily?: WebCapabilityFamily;
+    taskMode?: WebTaskMode;
+    executionMode?: WebExecutionMode;
+    statefulness?: WebStatefulness;
+    approvalDefault?: WebApprovalDefault;
+    policyRiskClass?: WebPolicyRiskClass;
+    riskLevel?: ToolRiskLevel;
+    allowedActionScopes?: WebActionScope[];
+    degradationTarget?: WebDegradationTarget;
+    upgradeTargets?: WebCapabilityId[];
+    escalationReasons?: WebEscalationReason[];
+    retryPolicy?: WebRetryPolicy;
+    [key: string]: unknown;
+};
+export type CapabilitySkillManifestContract = {
+    name: string;
+    description: string;
+    source: string;
+    eligible: boolean;
+    disabled: boolean;
+    [key: string]: unknown;
+};
+export type CapabilityPluginManifestContract = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    status: "loaded" | "disabled" | "error";
+    [key: string]: unknown;
+};
+export type CapabilityMcpManifestContract = {
+    id: string;
+    name: string;
+    enabled: boolean;
+    status: "connected" | "disconnected" | "error";
+    [key: string]: unknown;
+};
+export interface CapabilityManifestApprovalPolicyContract {
+    mode: CapabilityManifestApprovalMode;
+    execApprovalsConfigured: boolean;
+}
+export interface CapabilityWorkspaceSummaryContract {
+    id: string;
+    role?: string;
+}
+export interface CapabilityManifestSnapshotContract {
+    snapshotVersion: string;
+    updatedAt: string;
+    syncMode?: "full" | "diff";
+    baseSnapshotVersion?: string;
+    changedSections?: CapabilityManifestDiffSection[];
+    gatewayVersion?: string;
+    toolNamespaces: string[];
+    workspaceIds: string[];
+    installedCapabilities?: string[];
+    enabledCapabilities?: string[];
+    features?: string[];
+    approvalMode?: CapabilityManifestApprovalMode;
+    toolManifests?: CapabilityToolManifestContract[];
+    skillManifests?: CapabilitySkillManifestContract[];
+    pluginManifests?: CapabilityPluginManifestContract[];
+    mcpManifests?: CapabilityMcpManifestContract[];
+    approvalPolicy?: CapabilityManifestApprovalPolicyContract;
+    workspaceSummaries?: CapabilityWorkspaceSummaryContract[];
+}
+export interface HostCapabilitySnapshotContract extends CapabilityManifestSnapshotContract {
+    installedCapabilities?: string[];
+    enabledCapabilities?: string[];
+}
+export type ToolEligibilityStatus = "installed-disabled" | "installed-awaiting-approval" | "installed-ineligible-context" | "enabled-eligible" | "blocked-by-policy" | "unreachable-runtime";
+export type ToolEligibilityReasonCode = "host_disabled" | "approval_required" | "policy_blocked" | "context_mismatch" | "runtime_unreachable" | "not_installed";
+export type ToolEligibilityResolvedSource = "host-capability" | "plugin-manifest" | "mcp-manifest" | "policy" | "runtime-context";
+export interface RuntimeToolEligibilityContract {
+    toolName: string;
+    status: ToolEligibilityStatus;
+    approvalRequired: boolean;
+    reasonCodes: ToolEligibilityReasonCode[];
+    eligibilityReason?: ToolEligibilityReasonCode;
+    policyBlocked?: boolean;
+    contextEligible?: boolean;
+    resolvedSource?: ToolEligibilityResolvedSource;
+    hostLocalOnly?: boolean;
+}
+export interface RuntimeCapabilityViewContract {
+    snapshotVersion: string;
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+    eligibleTools: RuntimeToolEligibilityContract[];
+    ineligibleTools: RuntimeToolEligibilityContract[];
+    approvalRequiredTools?: ApprovalRequiredToolContract[];
+}
+export declare function cloneCapabilityManifestSnapshot<T extends CapabilityManifestSnapshotContract>(snapshot: T): T;
+export declare function mergeCapabilityManifestSnapshot(params: {
+    previous?: CapabilityManifestSnapshotContract | null;
+    update: CapabilityManifestSnapshotContract;
+}): CapabilityManifestSnapshotContract;
+export declare function deriveCapabilityToolNamespaces(toolManifests: ReadonlyArray<Pick<CapabilityToolManifestContract, "name">>): string[];
+export declare function deriveCapabilityWorkspaceIds(workspaceSummaries: ReadonlyArray<Pick<CapabilityWorkspaceSummaryContract, "id">>): string[];
+export declare function createCapabilityManifestDiffPayload<T extends CapabilityManifestSnapshotContract>(params: {
+    previous?: T | null;
+    current: T;
+}): T | null;

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

@@ -0,0 +1,149 @@
+export const CAPABILITY_MANIFEST_DIFF_SECTIONS = [
+    "gatewayVersion",
+    "toolNamespaces",
+    "workspaceIds",
+    "installedCapabilities",
+    "enabledCapabilities",
+    "features",
+    "approvalMode",
+    "toolManifests",
+    "skillManifests",
+    "pluginManifests",
+    "mcpManifests",
+    "approvalPolicy",
+    "workspaceSummaries",
+];
+function cloneRecordArray(items) {
+    return items ? items.map((item) => ({ ...item })) : undefined;
+}
+function cloneWorkspaceSummaryArray(items) {
+    return items ? items.map((item) => ({ ...item })) : undefined;
+}
+function cloneStringArray(values) {
+    return values ? [...values] : undefined;
+}
+function sortUniqueStrings(values) {
+    return [...new Set(values.map((value) => value.trim()).filter(Boolean))].sort((left, right) => left.localeCompare(right));
+}
+export function cloneCapabilityManifestSnapshot(snapshot) {
+    return {
+        ...snapshot,
+        toolNamespaces: [...snapshot.toolNamespaces],
+        workspaceIds: [...snapshot.workspaceIds],
+        ...(snapshot.changedSections ? { changedSections: [...snapshot.changedSections] } : {}),
+        ...(snapshot.installedCapabilities ? { installedCapabilities: [...snapshot.installedCapabilities] } : {}),
+        ...(snapshot.enabledCapabilities ? { enabledCapabilities: [...snapshot.enabledCapabilities] } : {}),
+        ...(snapshot.features ? { features: [...snapshot.features] } : {}),
+        ...(snapshot.toolManifests ? { toolManifests: cloneRecordArray(snapshot.toolManifests) } : {}),
+        ...(snapshot.skillManifests ? { skillManifests: cloneRecordArray(snapshot.skillManifests) } : {}),
+        ...(snapshot.pluginManifests ? { pluginManifests: cloneRecordArray(snapshot.pluginManifests) } : {}),
+        ...(snapshot.mcpManifests ? { mcpManifests: cloneRecordArray(snapshot.mcpManifests) } : {}),
+        ...(snapshot.approvalPolicy ? { approvalPolicy: { ...snapshot.approvalPolicy } } : {}),
+        ...(snapshot.workspaceSummaries
+            ? { workspaceSummaries: cloneWorkspaceSummaryArray(snapshot.workspaceSummaries) }
+            : {}),
+    };
+}
+export function mergeCapabilityManifestSnapshot(params) {
+    const { previous, update } = params;
+    const canMergeDiff = update.syncMode === "diff"
+        && previous
+        && (!update.baseSnapshotVersion || previous.snapshotVersion === update.baseSnapshotVersion);
+    if (!canMergeDiff || !previous) {
+        return cloneCapabilityManifestSnapshot(update);
+    }
+    const merged = cloneCapabilityManifestSnapshot(previous);
+    return {
+        ...merged,
+        snapshotVersion: update.snapshotVersion,
+        updatedAt: update.updatedAt,
+        ...(update.gatewayVersion !== undefined ? { gatewayVersion: update.gatewayVersion } : {}),
+        ...(update.syncMode ? { syncMode: update.syncMode } : {}),
+        ...(update.baseSnapshotVersion ? { baseSnapshotVersion: update.baseSnapshotVersion } : {}),
+        ...(update.changedSections ? { changedSections: [...update.changedSections] } : {}),
+        ...(update.toolNamespaces ? { toolNamespaces: [...update.toolNamespaces] } : {}),
+        ...(update.workspaceIds ? { workspaceIds: [...update.workspaceIds] } : {}),
+        ...(update.installedCapabilities ? { installedCapabilities: [...update.installedCapabilities] } : {}),
+        ...(update.enabledCapabilities ? { enabledCapabilities: [...update.enabledCapabilities] } : {}),
+        ...(update.features ? { features: [...update.features] } : {}),
+        ...(update.approvalMode ? { approvalMode: update.approvalMode } : {}),
+        ...(update.toolManifests ? { toolManifests: cloneRecordArray(update.toolManifests) } : {}),
+        ...(update.skillManifests ? { skillManifests: cloneRecordArray(update.skillManifests) } : {}),
+        ...(update.pluginManifests ? { pluginManifests: cloneRecordArray(update.pluginManifests) } : {}),
+        ...(update.mcpManifests ? { mcpManifests: cloneRecordArray(update.mcpManifests) } : {}),
+        ...(update.approvalPolicy ? { approvalPolicy: { ...update.approvalPolicy } } : {}),
+        ...(update.workspaceSummaries
+            ? { workspaceSummaries: cloneWorkspaceSummaryArray(update.workspaceSummaries) }
+            : {}),
+    };
+}
+export function deriveCapabilityToolNamespaces(toolManifests) {
+    return sortUniqueStrings(toolManifests
+        .map((manifest) => manifest.name.split(".")[0] ?? "")
+        .filter(Boolean));
+}
+export function deriveCapabilityWorkspaceIds(workspaceSummaries) {
+    return sortUniqueStrings(workspaceSummaries.map((summary) => summary.id));
+}
+export function createCapabilityManifestDiffPayload(params) {
+    const { previous, current } = params;
+    if (!previous) {
+        return {
+            ...cloneCapabilityManifestSnapshot(current),
+            syncMode: "full",
+        };
+    }
+    if (previous.snapshotVersion === current.snapshotVersion) {
+        return null;
+    }
+    const changedSections = CAPABILITY_MANIFEST_DIFF_SECTIONS.filter((section) => JSON.stringify(previous[section]) !== JSON.stringify(current[section]));
+    if (changedSections.length === CAPABILITY_MANIFEST_DIFF_SECTIONS.length) {
+        return {
+            ...cloneCapabilityManifestSnapshot(current),
+            syncMode: "full",
+        };
+    }
+    const payload = {
+        snapshotVersion: current.snapshotVersion,
+        updatedAt: current.updatedAt,
+        syncMode: "diff",
+        baseSnapshotVersion: previous.snapshotVersion,
+        changedSections,
+        toolNamespaces: [...current.toolNamespaces],
+        workspaceIds: [...current.workspaceIds],
+    };
+    const payloadRecord = payload;
+    for (const section of changedSections) {
+        const value = current[section];
+        if (value === undefined) {
+            continue;
+        }
+        switch (section) {
+            case "toolNamespaces":
+            case "workspaceIds":
+            case "installedCapabilities":
+            case "enabledCapabilities":
+            case "features":
+                payloadRecord[section] = cloneStringArray(value);
+                break;
+            case "approvalPolicy":
+                payloadRecord[section] = {
+                    ...value,
+                };
+                break;
+            case "workspaceSummaries":
+                payloadRecord[section] = cloneWorkspaceSummaryArray(value);
+                break;
+            case "toolManifests":
+            case "skillManifests":
+            case "pluginManifests":
+            case "mcpManifests":
+                payloadRecord[section] = cloneRecordArray(value);
+                break;
+            default:
+                payloadRecord[section] = value;
+                break;
+        }
+    }
+    return payload;
+}

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

@@ -0,0 +1,207 @@
+import type { ProxyKeySource } from "./transport.js";
+import type { MemoryContextBlock } from "./memory-provider-lifecycle.js";
+import type { WebCapabilityFamily, WebTaskMode, WebExecutionMode, WebStatefulness, WebPolicyRiskClass, ToolRiskLevel } from "./web-capability.js";
+export interface TransportCapabilitySummaryContract {
+    snapshotVersion: string;
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+    eligibleToolCount?: number;
+    ineligibleToolCount?: number;
+}
+export interface TransportApprovalRequiredToolHintEntry {
+    toolName: string;
+    reasonCodes?: string[];
+}
+export interface TransportToolEligibilitySummaryEntry {
+    toolName: string;
+    status: string;
+    approvalRequired: boolean;
+    reasonCodes?: string[];
+    eligibilityReason?: string;
+    policyBlocked?: boolean;
+    contextEligible?: boolean;
+    resolvedSource?: string;
+}
+export interface CapabilityInstallStateSummary {
+    installedCapabilities: string[];
+    enabledCapabilities: string[];
+}
+export interface CapabilityPolicyHintEntry {
+    code: string;
+    scope?: string;
+    message?: string;
+}
+export interface AgentTurnRequestSpec {
+    modality?: "text" | "image" | "video" | "audio" | "music";
+    params?: Record<string, unknown>;
+}
+export interface AgentTurnLocalContext {
+    capabilitySnapshotVersion?: string;
+    toolNamespaces?: string[];
+    workspaceIds?: string[];
+    capabilitySummary?: TransportCapabilitySummaryContract;
+    approvalRequiredToolHint?: TransportApprovalRequiredToolHintEntry[];
+    eligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    ineligibleToolSummary?: TransportToolEligibilitySummaryEntry[];
+    memoryContextBlocks?: MemoryContextBlock[];
+}
+export interface AgentTurnClientHints {
+    uiSurface?: string;
+    locale?: string;
+}
+export interface AgentTurnAttachment {
+    id?: string;
+    type?: string;
+    mimeType?: string;
+    url?: string;
+    name?: string;
+}
+export interface AgentTurnConversation {
+    messages: unknown[];
+    attachments?: AgentTurnAttachment[];
+    summary?: string;
+}
+export interface AgentTurnExperience {
+    mode?: string;
+    modelAlias?: string;
+    stream?: boolean;
+    responseFormat?: string;
+    keySource?: ProxyKeySource;
+}
+export interface ToolExecutionStepContext {
+    stepIndex?: number;
+    stepTotal?: number;
+    stepSummary?: string;
+    selectedCapabilityId?: string;
+    selectedCapabilityFamily?: WebCapabilityFamily;
+    selectedTaskMode?: WebTaskMode;
+    displayRiskLabel?: string;
+    displayFallbackLabel?: string;
+    displayBlockedLabel?: string;
+    decisionReasonCode?: string;
+    fallbackPlanRef?: string;
+}
+export interface ToolInvokeApprovalDescriptor extends ToolExecutionStepContext {
+    mode?: "user-confirm" | "pre-authorized";
+    reason?: string;
+}
+export interface CapabilityToolManifestEntry {
+    name: string;
+    label: string;
+    description: string;
+    source: "core" | "plugin";
+    category?: "core" | "media" | "browser" | "session" | "system" | "think";
+    groupId?: string;
+    pluginId?: string;
+    optional?: boolean;
+    defaultProfiles?: string[];
+    requiredParameters?: string[];
+    parametersSummary?: string;
+    riskLevel?: ToolRiskLevel;
+    approvalMode?: "user-confirm" | "pre-authorized";
+    requiresApproval?: boolean;
+    parallelSafe?: boolean;
+    serialOnly?: boolean;
+    recoverable?: boolean;
+    resultMode?: "final";
+    capabilityId?: string;
+    capabilityFamily?: WebCapabilityFamily;
+    taskMode?: WebTaskMode;
+    executionMode?: WebExecutionMode;
+    statefulness?: WebStatefulness;
+    approvalDefault?: "required" | "conditional" | "none";
+    policyRiskClass?: WebPolicyRiskClass;
+    requiresRuntimeBackend?: boolean;
+    requiresHostBridge?: boolean;
+    supportsRenderBackend?: boolean;
+    supportsLoginState?: boolean;
+    supportsPersistentProfile?: boolean;
+    supportsSharedSessionReuse?: boolean;
+    supportsTransactionality?: "read-only" | "state-changing";
+    allowedActionScopes?: string[];
+    degradationTarget?: string;
+    upgradeTargets?: string[];
+    fallbackChain?: string[];
+    escalationReasons?: string[];
+    auditRequired?: boolean;
+    requiresUserVisibleStep?: boolean;
+    retryPolicy?: "none" | "same-capability-once" | "degrade-only";
+    repairAfterDenied?: boolean;
+    repairAfterUnavailable?: boolean;
+    displayRiskLabel?: string;
+    displayBlockedLabel?: string;
+    displayFallbackLabel?: string;
+}
+export interface CapabilitySkillManifestEntry {
+    name: string;
+    description: string;
+    source: string;
+    eligible: boolean;
+    disabled: boolean;
+    category?: string;
+    installable?: boolean;
+}
+export interface CapabilityPluginManifestEntry {
+    id: string;
+    name: string;
+    version?: string;
+    description?: string;
+    kind?: string;
+    origin?: string;
+    enabled: boolean;
+    status: "loaded" | "disabled" | "error";
+    error?: string;
+    hasConfigSchema?: boolean;
+    capabilityFlags?: string[];
+}
+export interface CapabilityMcpManifestEntry {
+    id: string;
+    name: string;
+    enabled: boolean;
+    status: "connected" | "disconnected" | "error";
+    serverKind?: string;
+    tools?: string[];
+}
+export interface CapabilityApprovalPolicy {
+    mode: "user-confirm" | "pre-authorized";
+    execApprovalsConfigured: boolean;
+}
+export interface CapabilityWorkspaceSummary {
+    id: string;
+    role?: string;
+}
+export interface CapabilitySyncPayload {
+    snapshotVersion: string;
+    updatedAt: string;
+    syncMode?: "full" | "diff";
+    baseSnapshotVersion?: string;
+    changedSections?: string[];
+    gatewayVersion?: string;
+    toolNamespaces: string[];
+    workspaceIds: string[];
+    installedCapabilities?: string[];
+    enabledCapabilities?: string[];
+    features?: string[];
+    approvalMode?: "user-confirm" | "pre-authorized";
+    toolManifests?: CapabilityToolManifestEntry[];
+    skillManifests?: CapabilitySkillManifestEntry[];
+    pluginManifests?: CapabilityPluginManifestEntry[];
+    mcpManifests?: CapabilityMcpManifestEntry[];
+    approvalPolicy?: CapabilityApprovalPolicy;
+    policyHints?: CapabilityPolicyHintEntry[];
+    workspaceSummaries?: CapabilityWorkspaceSummary[];
+}
+export interface CapabilitySyncMsg extends CapabilitySyncPayload {
+    type: "capability.sync";
+    id: string;
+}
+export interface CapabilitySyncAckPayload {
+    success: true;
+    snapshotVersion: string;
+    receivedAt: string;
+}
+export interface CapabilitySyncAckMsg {
+    type: "capability.sync.ack";
+    id: string;
+    payload: CapabilitySyncAckPayload;
+}

package/dist/protocol/wire/capability-transport.js

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

package/dist/protocol/wire/channel-ingress.d.ts

@@ -0,0 +1,29 @@
+export type GatewayChannelExecutionIngressSource = "channel-ingress";
+export type GatewayChannelExecutionEgressKind = "partial" | "final" | "approval" | "error" | "artifact" | "control";
+export interface GatewayChannelExecutionIngressBindingContract {
+    requestId: string;
+    gatewayTargetRef: string;
+    channelRequestId: string;
+    replyTargetRef: string;
+    channelType: string;
+    channelConversationId: string;
+    channelUserId: string;
+    dedupeKey: string;
+    receivedAt: string;
+    source: GatewayChannelExecutionIngressSource;
+}
+export interface GatewayChannelExecutionEgressContract {
+    requestId: string;
+    replyTargetRef: string;
+    channelRequestId?: string;
+    sessionId?: string;
+    turnId?: string;
+    executionId?: string;
+    rootExecutionId?: string;
+    parentExecutionId?: string;
+    sidechainId?: string;
+    attemptId?: string;
+    envelopeKind: GatewayChannelExecutionEgressKind;
+    emittedAt: string;
+    terminal: boolean;
+}

package/dist/protocol/wire/channel-ingress.js

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

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

@@ -0,0 +1,89 @@
+export type NormalizedChannelType = "telegram" | "slack" | "whatsapp" | "discord" | "wechat" | "custom";
+export type NormalizedChannelMessagePartType = "text" | "image" | "audio" | "video" | "file" | "location" | "event" | "custom";
+export type NormalizedChannelRetryBackoffPolicy = "fixed" | "exponential" | "provider-managed";
+export type NormalizedChannelIdempotencyScope = "reply-target" | "conversation" | "channel-request";
+export type NormalizedChannelDeliveryStatus = "pending" | "delivered" | "retrying" | "failed" | "expired" | "cancelled";
+export interface NormalizedChannelMessagePart {
+    partType: NormalizedChannelMessagePartType;
+    text?: string;
+    mimeType?: string;
+    assetRef?: string;
+    sizeBytes?: number;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelAttachment {
+    attachmentId: string;
+    mimeType?: string;
+    filename?: string;
+    downloadUrl?: string;
+    assetRef?: string;
+    sizeBytes?: number;
+}
+export interface NormalizedChannelExecutionHints {
+    intent?: string;
+    locale?: string;
+    expectsReply?: boolean;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelDeliveryPolicy {
+    allowEdit?: boolean;
+    allowReplyThread?: boolean;
+    maxRetryCount?: number;
+    retryBackoffPolicy?: NormalizedChannelRetryBackoffPolicy;
+    idempotencyScope?: NormalizedChannelIdempotencyScope;
+}
+export interface NormalizedChannelInboundRequest {
+    channelRequestId: string;
+    channelType: NormalizedChannelType;
+    channelTenantId?: string;
+    channelConversationId: string;
+    channelUserId: string;
+    receivedAt: string;
+    dedupeKey: string;
+    gatewayTargetRef: string;
+    replyTargetRef: string;
+    messageParts: NormalizedChannelMessagePart[];
+    attachments?: NormalizedChannelAttachment[];
+    executionHints?: NormalizedChannelExecutionHints;
+}
+export interface NormalizedChannelReplyTarget {
+    replyTargetRef: string;
+    channelType: NormalizedChannelType;
+    channelTenantId?: string;
+    channelConversationId: string;
+    channelMessageRef?: string;
+    recipientRef: string;
+    threadRef?: string;
+    expiresAt?: string;
+    deliveryPolicy?: NormalizedChannelDeliveryPolicy;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelReplyRequest {
+    deliveryAttemptId: string;
+    replyTargetRef: string;
+    channelType: NormalizedChannelType;
+    channelTenantId?: string;
+    channelConversationId: string;
+    recipientRef: string;
+    threadRef?: string;
+    replyToMessageId: string;
+    gatewayId: string;
+    text?: string;
+    mediaUrl?: string;
+    mediaUrls?: string[];
+    fileName?: string;
+    mimeType?: string;
+    data?: Record<string, unknown>;
+}
+export interface NormalizedChannelDeliveryOutcome {
+    deliveryAttemptId: string;
+    replyTargetRef: string;
+    deliveryStatus: NormalizedChannelDeliveryStatus;
+    providerMessageRef?: string;
+    providerErrorCode?: string;
+    providerErrorMessage?: string;
+    attemptedAt: string;
+    ackedAt?: string;
+    retryCount: number;
+    nextRetryAt?: string;
+}

package/dist/protocol/wire/channel.js

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