@addozhang/dsh-discord 0.1.0

package/lib/features/image-submission.js

@@ -0,0 +1,57 @@
+/**
+ * Image submission through `session.prompt` (design.md §12, task 12.3).
+ * Mixed text/images encode into ordered prompt parts; the model's modality
+ * is checked BEFORE any DSH call; and the request id claims an intent so a
+ * duplicate Discord delivery never resubmits. Host outcomes map to values
+ * with the intent state kept honest (failed on rejection, unknown preserved
+ * for reconciliation).
+ */
+import { hashPayload } from '../state/intents.js';
+/** Encode text plus images into ordered prompt parts. */
+export function encodePromptParts(text, images) {
+    const parts = [];
+    const trimmed = text.trim();
+    if (trimmed !== '')
+        parts.push({ type: 'text', text: trimmed });
+    for (const image of images) {
+        parts.push({ type: 'image', mediaType: image.mediaType, data: image.base64 });
+    }
+    return parts;
+}
+export function createImageSubmissionFlow(deps) {
+    return {
+        async submit(request) {
+            const parts = encodePromptParts(request.text, request.images);
+            // Modality gate: refuse BEFORE the intent claim so an explicit user
+            // retry with a text-only message is a clean new attempt.
+            if (request.images.length > 0 && !deps.modality()) {
+                return { outcome: 'refused', reason: 'unsupported-modality' };
+            }
+            const contentHash = await hashPayload({ sessionId: request.sessionId, parts });
+            const claim = await deps.intents.claim({
+                messageId: request.requestId,
+                contentHash,
+                claimedAtMs: deps.nowMs(),
+            });
+            if (claim.outcome === 'conflict')
+                return { outcome: 'conflict' };
+            if (claim.outcome === 'duplicate')
+                return { outcome: 'already-submitted' };
+            const submitted = await deps.prompts.submit({
+                requestId: request.requestId,
+                sessionId: request.sessionId,
+                parts,
+            });
+            if (submitted.outcome === 'accepted') {
+                await deps.intents.resolve(request.requestId, 'succeeded', deps.nowMs());
+                return { outcome: 'accepted' };
+            }
+            if (submitted.outcome === 'rejected') {
+                await deps.intents.resolve(request.requestId, 'failed', deps.nowMs());
+                return { outcome: 'rejected' };
+            }
+            await deps.intents.resolve(request.requestId, 'unknown', deps.nowMs());
+            return { outcome: 'unknown' };
+        },
+    };
+}

package/lib/features/interaction-router.d.ts

@@ -0,0 +1,84 @@
+/**
+ * The interaction router (extracted from the Host composition root so the
+ * whole command/component surface is testable against the Discord API twin).
+ * Every path re-checks authorization where the event alone cannot prove it
+ * (workspace-administrator level, catalog freshness), answers interactions
+ * through the deferred-ack + ephemeral-followup pattern, and maps every DSH
+ * outcome onto caller-facing copy without ever retrying.
+ */
+import type { ComponentRegistry } from '../discord/components.js';
+import type { SharedRestClient } from '../discord/rest.js';
+import { type PolicyTable } from '../policy/authorization.js';
+import { type ProjectListPort } from './project-list.js';
+import type { WorkspaceResolver } from './project-bind.js';
+import type { CancelOutcome, PromptOutcome, QueueRemoveOutcome, WorkspaceDetailOutcome } from '../dsh/api-proxy-face.js';
+import type { TurnTracker } from './turn-ownership.js';
+import { type DshApprovalRespondPort } from './approval-routing.js';
+import type { QuestionInteractionOutcome } from './question-routing.js';
+import type { ApprovalStore } from './approval-store.js';
+import type { ChannelBinding } from '../state/records.js';
+import type { NormalizedInteraction } from '../gateway/inbound.js';
+import type { CopyTable } from '../i18n.js';
+/** The DSH faces the control commands submit through (apiProxy-backed). */
+export interface InteractionDshFace {
+    cancel(sessionId: string): Promise<CancelOutcome>;
+    steer(sessionId: string, prompt: string): Promise<PromptOutcome>;
+    removeQueueItem(sessionId: string, itemId: string): Promise<QueueRemoveOutcome>;
+    readWorkspaceDetail(reference: string): Promise<WorkspaceDetailOutcome>;
+}
+export interface InteractionRouterDeps {
+    policy: () => PolicyTable;
+    applicationId: () => string;
+    /** The shared component registry (render + click routing use one instance). */
+    registry: ComponentRegistry;
+    /** Discord-visible copy, resolved per access (language can change live). */
+    copy: CopyTable;
+    approvals: ApprovalStore;
+    approvalRespondPort: DshApprovalRespondPort;
+    turnTracker: TurnTracker;
+    /** Latest mux queue snapshots per session — the /queue surface's source. */
+    queueSnapshots: Map<string, Array<{
+        id: string;
+        summary: string;
+    }>>;
+    dsh: InteractionDshFace;
+    catalogPort: ProjectListPort;
+    resolver: WorkspaceResolver;
+    channelBinding: (guildId: string, channelId: string) => ChannelBinding | undefined;
+    findBoundChannelFor: (guildId: string, workspaceId: string) => string | undefined;
+    sessionForThread: (guildId: string, threadId: string) => string | undefined;
+    ensureWorkspaceChannel: (options: {
+        guildId: string;
+        workspaceId: string;
+        title: string;
+        actorId: string;
+    }) => Promise<{
+        channelId: string;
+        created: boolean;
+    } | undefined>;
+    /** Delete every adapter-owned record for one guild (DSH untouched). */
+    forgetGuild: (guildId: string) => Promise<void>;
+    /** Ephemeral failure/guidance followup on a component interaction. */
+    componentFollowUp: (interactionId: string, interactionToken: string, content: string) => Promise<void>;
+    /** Retire a rendered control (remove its components on the source message). */
+    disableControl: (key: string) => Promise<void>;
+    /** Question select/submit clicks and modal submits (module-tested routing). */
+    handleQuestionComponent: (input: {
+        customId: string;
+        userId: string;
+        threadId: string;
+        values: string[];
+    }) => Promise<QuestionInteractionOutcome>;
+    handleQuestionModal: (input: {
+        customId: string;
+        userId: string;
+        threadId: string;
+        text: string;
+    }) => QuestionInteractionOutcome;
+    rest: () => Promise<SharedRestClient | undefined>;
+    log: (event: string, detail?: unknown) => void;
+    warn: (event: string, detail?: unknown) => void;
+}
+export declare function createInteractionRouter(deps: InteractionRouterDeps): {
+    route(event: NormalizedInteraction, interactionToken?: string): Promise<void>;
+};