super-dsh 0.1.0 → 0.1.1

package/agent-agy/dist/agent-preset-projection.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Antigravity provider replaces preset composition
+ * wholesale). But the Web UI depends on the projection regardless: the preset
+ * hero chip renders only when `session.projectionValues.agentPreset` resolves
+ * (presetOf in ui-agent-preset/seat-store.ts), and the session-header label
+ * reads it too. Without a registrant the projection is absent for every
+ * adapter session and both surfaces stay blank — roster or no roster.
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this adapter synthesizes (`"agy"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export declare const agyAgentPresetProjection: {
+    key: "agentPreset";
+    stateSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    init: (header: import("@deepseek-ai/dsh-session").SessionHeader) => string;
+    apply: (state: string | null, event: import("@deepseek-ai/dsh-session").SessionEvent) => string | null;
+    wire: {
+        viewSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        view: (state: string | null) => string | null;
+    };
+    stateVersion: number;
+};

package/agent-agy/dist/agent-preset-projection.js

@@ -0,0 +1,33 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Antigravity provider replaces preset composition
+ * wholesale). But the Web UI depends on the projection regardless: the preset
+ * hero chip renders only when `session.projectionValues.agentPreset` resolves
+ * (presetOf in ui-agent-preset/seat-store.ts), and the session-header label
+ * reads it too. Without a registrant the projection is absent for every
+ * adapter session and both surfaces stay blank — roster or no roster.
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this adapter synthesizes (`"agy"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const agyAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // adapter-agy is single-preset: default every session to "agy" so the
+    // header chip resolves for scan-native (never-resumed) sessions too.
+    init: (header) => header.agentPreset ?? "agy",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};

package/agent-agy/dist/agent.d.ts

@@ -0,0 +1,137 @@
+/**
+ * AgyAgent — the Dash `Agent` shim over one `AgyBridgeClient` (the Python SDK
+ * bridge child; localharness materializes inside it on the first prompt).
+ *
+ * Projection (bridge → Dash session events):
+ *   (prompt delivery)   → turn/start + user/message
+ *   chunk (streamed)    → assistant stream frames (v2 protocol) accumulated
+ *                         as durable records; the FULL text commits once as
+ *                         assistant/message at `done`
+ *   tool                → (V1: bridge supplies name only — omitted from the
+ *                         log rather than fabricated; event-stream honesty)
+ *   done                → assistant/message + step/end + turn/end {completed}
+ *   error               → turn/end {error} with a stable code
+ *
+ * Bridge gaps registered explicitly (never fabricated):
+ * - token usage: the bridge `done` event carries none → no usage field.
+ * - tool fidelity: only a tool name arrives (no call id / args / result) → no
+ *   tool/call or tool/result events in V1.
+ * - steer/cancel: the bridge has no in-turn interrupt; `steer` degrades to a
+ *   parked follow-up, `cancel` records the cause (applied at the terminal).
+ *
+ * Onboarding (§17 minimal, consumer-first): when no Gemini API key is known,
+ * the first user turn never touches the bridge — the turn is answered locally
+ * with a system/message asking for the key; a pasted key is persisted through
+ * `onApiKey` (adapter state, world home only) and confirmed in the same turn.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent, AgentOptions, AgentStatus, CancelOptions, InboxTarget } from "@deepseek-ai/dsh-agent";
+import { Inbox } from "./inbox.js";
+import type { AgentCancelCause, Session, SessionId, UserMessage } from "@deepseek-ai/dsh-session";
+import type { TokenUsage } from "@deepseek-ai/dsh-llm";
+import type { AgyBridgeClient } from "./agy-client.js";
+/** Structural union of the two live transports (SDK bridge | CLI stream). */
+export type LiveAgyClient = Pick<AgyBridgeClient, "conversationId" | "lastUsage" | "onThinkingDelta" | "onToolEvent" | "setApprovalHandler" | "turn" | "close"> & {
+    setSystemMessageHandler?(handler: (text: string) => void): void;
+};
+/** Classify a bridge turn failure into the stable {message, code} UI chip. */
+export declare function classifyTurnError(error: unknown): {
+    message: string;
+    code: string;
+};
+/** Join the visible text blocks of a Dash user message into the prompt string. */
+export declare function userMessageText(message: UserMessage): string;
+/** Whether a raw user text looks like a pasteable Gemini API key. */
+export declare function looksLikeApiKey(text: string): boolean;
+/** Runtime facts the provider stamps the agent with (mirrors hermes). */
+export interface AgyAgentRuntimeInfo {
+    /** Session materialization context for the bridge (first prompt). */
+    readonly session: {
+        cwd: string;
+    };
+    /** True when no Gemini API key is known: turns are answered locally. */
+    readonly awaitingKey: boolean;
+    /** Persist a pasted key (adapter state, world home ONLY). */
+    readonly onSaveApiKey: (key: string) => void;
+    /** Fired after each bridge turn completes (the provider upserts the conversation id). */
+    readonly onTurnDone?: () => void;
+}
+export declare class AgyAgent implements Agent {
+    readonly id: SessionId;
+    readonly options: AgentOptions;
+    readonly session: Session;
+    readonly inbox: Inbox;
+    readonly ctx: Context;
+    private readonly client;
+    private readonly loopCtx;
+    private readonly scope;
+    private readonly dispatch;
+    private readonly runtimeInfo;
+    private streaming;
+    private dashTurn;
+    private step;
+    private lastTurn;
+    private turnOpen;
+    private cancelCause;
+    private streamBridge;
+    private assistantAttemptCounter;
+    private assistantStreamRevision;
+    private remoteQueue;
+    private turnDeadlineTimer;
+    private disposed;
+    private systemMessageDone;
+    private activityDone;
+    private resolveActivityDone;
+    private readonly onIdleExit;
+    constructor(loopCtx: Context, id: SessionId, options: AgentOptions, session: Session, client: LiveAgyClient, onIdleExit?: () => void, runtimeInfo?: AgyAgentRuntimeInfo);
+    get status(): AgentStatus;
+    send(message: UserMessage, _target: InboxTarget, wakeup: boolean): void;
+    followup(message: UserMessage): void;
+    /** No native steer surface on the bridge (V1 gap): degrade to a parked follow-up. */
+    steer(message: UserMessage): void;
+    inject(message: UserMessage): void;
+    /** The bridge has no in-turn interrupt (V1 gap): record the cause; applied at the terminal. */
+    cancel(cause: AgentCancelCause, _options?: CancelOptions): void;
+    whenIdle(): Promise<void>;
+    runMaintenance<T>(task: (signal: AbortSignal) => Promise<T>): Promise<T>;
+    dispose(): Promise<void>;
+    private deliver;
+    private deliverPrompt;
+    private sessionIdentityCommitted;
+    /** Stamp the single-preset selection once per session (projection seed). */
+    private bootstrapSessionIdentity;
+    private startTurn;
+    private appendSystemNotice;
+    private appendAssistantMessage;
+    private ensureStreamBridge;
+    private abandonStreamBridge;
+    private reserveTurn;
+    private closeTurn;
+    private closeStep;
+    private commitStepStart;
+    /** One-shot system stamp: the onboarding notice rides the first turn. */
+    private markRunning;
+    private markIdle;
+    private beginActivity;
+    private endActivity;
+    /** Flush ONE parked follow-up as a fresh prompt (never submit while busy). */
+    private flushFollowUps;
+    private pendingThinking;
+    /** Calls from this turn still lacking a result (SDK 0.1.17 exposes none). */
+    private unpairedCalls;
+    private armTurnDeadline;
+    private clearTurnDeadline;
+}
+/**
+ * Map the bridge's best-effort usage event into Dash `TokenUsage`. The bridge
+ * derives it from `conversation.last_turn_usage` AFTER the stream — when it is
+ * absent there is NO usage field (never fabricated). `thinking_tokens` rides
+ * along only when it is a subset of `output_tokens` (the DSH fold rejects a
+ * larger value outright).
+ */
+export declare function convertAgyUsage(usage: {
+    input_tokens: number;
+    output_tokens: number;
+    thinking_tokens: number;
+    total_tokens: number;
+} | undefined): TokenUsage | undefined;