@classic-homes/agent-chat 0.0.0-stage → 0.1.1

package/dist/reducer.d.ts

@@ -0,0 +1,96 @@
+import type { ArtifactMediaType, BackendMode, ChatEvent, ClientKind, DocumentContext, FileRef, ProposedOperation, ToolResultStatus } from '@classic-homes/agent-contracts';
+import type { ClientErrorCode } from '@classic-homes/agent-client';
+/**
+ * Pure state model for one conversation view. `applyEvent` folds stream events into the
+ * assistant turn so the UI (and tests) never interpret events themselves.
+ */
+export interface ToolCallState {
+    callId: string;
+    name: string;
+    server?: string;
+    argsPreview: string;
+    agent: string;
+    runId: string;
+    parentRunId?: string;
+    status?: ToolResultStatus;
+    durationMs?: number;
+    summary?: string;
+}
+export interface DelegationState {
+    child: string;
+    childRunId: string;
+    status: 'start' | 'end';
+    summary?: string;
+}
+export interface Artifact {
+    artifactId: string;
+    mediaType: ArtifactMediaType;
+    title?: string;
+    language?: string;
+    text: string;
+    open: boolean;
+}
+export interface UiResourceState {
+    callId: string;
+    uri: string;
+    html: string;
+    preferredFrameSize?: [string, string];
+}
+export interface FileState {
+    fileId: string;
+    name: string;
+    mimeType: string;
+    bytes: number;
+    path: string;
+}
+export interface UsageState {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    calls: number;
+}
+export type AssistantStatus = 'streaming' | 'done' | 'cancelled' | 'error' | 'incomplete';
+export interface UserMessage {
+    id: string;
+    role: 'user';
+    text: string;
+    attachments: FileRef[];
+    contextLabel?: string;
+    createdAt: number;
+}
+export interface AssistantMessage {
+    id: string;
+    role: 'assistant';
+    requestId: string;
+    text: string;
+    status: AssistantStatus;
+    tools: ToolCallState[];
+    delegations: DelegationState[];
+    artifacts: Artifact[];
+    ui: UiResourceState[];
+    files: FileState[];
+    proposals: ProposedOperation[];
+    usage: UsageState;
+    error?: {
+        code: ClientErrorCode;
+        message: string;
+        retryable: boolean;
+    };
+    finishReason?: 'stop' | 'length' | 'cancelled' | 'error';
+    mode?: BackendMode;
+    createdAt: number;
+}
+export type ChatMessage = UserMessage | AssistantMessage;
+export declare function newAssistantMessage(requestId: string, now?: number): AssistantMessage;
+export declare function newUserMessage(requestId: string, text: string, options?: {
+    attachments?: FileRef[];
+    context?: DocumentContext;
+    now?: number;
+}): UserMessage;
+export declare function describeContext(context: DocumentContext): string;
+/** Fold one stream event into the assistant message it belongs to. Returns a new object. */
+export declare function applyEvent(message: AssistantMessage, event: ChatEvent): AssistantMessage;
+/** Human titles for client error codes (mirrors the task pane's wording). */
+export declare function errorTitle(code: ClientErrorCode): string;
+export type { ClientKind };
+//# sourceMappingURL=reducer.d.ts.map

package/dist/reducer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../src/lib/reducer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,WAAW,EACX,SAAS,EACT,UAAU,EACV,eAAe,EACf,OAAO,EACP,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE;;;GAGG;AAEH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,gBAAgB,CAAC;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,GAAG,KAAK,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,QAAQ;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,CAAC;CACf;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,kBAAkB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,MAAM,GAAG,WAAW,GAAG,OAAO,GAAG,YAAY,CAAC;AAE1F,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,eAAe,CAAC;IACxB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,WAAW,EAAE,eAAe,EAAE,CAAC;IAC/B,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,EAAE,EAAE,eAAe,EAAE,CAAC;IACtB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,SAAS,EAAE,iBAAiB,EAAE,CAAC;IAC/B,KAAK,EAAE,UAAU,CAAC;IAClB,KAAK,CAAC,EAAE;QAAE,IAAI,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;IACvE,YAAY,CAAC,EAAE,MAAM,GAAG,QAAQ,GAAG,WAAW,GAAG,OAAO,CAAC;IACzD,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,WAAW,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAEzD,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,SAAa,GAAG,gBAAgB,CAgBzF;AAED,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE;IAAE,WAAW,CAAC,EAAE,OAAO,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,eAAe,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAO,GACjF,WAAW,CASb;AAED,wBAAgB,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,MAAM,CAIhE;AAED,4FAA4F;AAC5F,wBAAgB,UAAU,CAAC,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,SAAS,GAAG,gBAAgB,CAyIxF;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAiBxD;AAED,YAAY,EAAE,UAAU,EAAE,CAAC"}

package/dist/reducer.js

@@ -0,0 +1,186 @@
+export function newAssistantMessage(requestId, now = Date.now()) {
+    return {
+        id: `a-${requestId}`,
+        role: 'assistant',
+        requestId,
+        text: '',
+        status: 'streaming',
+        tools: [],
+        delegations: [],
+        artifacts: [],
+        ui: [],
+        files: [],
+        proposals: [],
+        usage: { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, calls: 0 },
+        createdAt: now,
+    };
+}
+export function newUserMessage(requestId, text, options = {}) {
+    return {
+        id: `u-${requestId}`,
+        role: 'user',
+        text,
+        attachments: options.attachments ?? [],
+        contextLabel: options.context ? describeContext(options.context) : undefined,
+        createdAt: options.now ?? Date.now(),
+    };
+}
+export function describeContext(context) {
+    if (context.host === 'excel')
+        return `${context.selection.sheet}!${context.selection.address}`;
+    if (context.host === 'word')
+        return context.selection.isEmpty ? 'Word cursor' : 'Word selection';
+    return context.record ? `${context.record.label}` : context.title;
+}
+/** Fold one stream event into the assistant message it belongs to. Returns a new object. */
+export function applyEvent(message, event) {
+    switch (event.type) {
+        case 'start':
+            return { ...message, mode: event.mode };
+        case 'delta':
+            return { ...message, text: message.text + event.text };
+        case 'proposal':
+            return message.proposals.some((p) => p.operationId === event.operation.operationId)
+                ? message
+                : { ...message, proposals: [...message.proposals, event.operation] };
+        case 'tool_call':
+            return {
+                ...message,
+                tools: [
+                    ...message.tools,
+                    {
+                        callId: event.callId,
+                        name: event.name,
+                        server: event.server,
+                        argsPreview: event.argsPreview,
+                        agent: event.agent,
+                        runId: event.runId,
+                        parentRunId: event.parentRunId,
+                    },
+                ],
+            };
+        case 'tool_result':
+            return {
+                ...message,
+                tools: message.tools.map((t) => t.callId === event.callId
+                    ? { ...t, status: event.status, durationMs: event.durationMs, summary: event.summary }
+                    : t),
+            };
+        case 'delegation': {
+            const existing = message.delegations.findIndex((d) => d.childRunId === event.childRunId);
+            const next = {
+                child: event.child,
+                childRunId: event.childRunId,
+                status: event.status,
+                summary: event.summary,
+            };
+            const delegations = existing === -1
+                ? [...message.delegations, next]
+                : message.delegations.map((d, i) => (i === existing ? { ...d, ...next } : d));
+            return { ...message, delegations };
+        }
+        case 'artifact': {
+            const idx = message.artifacts.findIndex((a) => a.artifactId === event.artifactId);
+            if (event.op === 'open') {
+                const artifact = {
+                    artifactId: event.artifactId,
+                    mediaType: event.mediaType ?? 'text/markdown',
+                    title: event.title,
+                    language: event.language,
+                    text: '',
+                    open: true,
+                };
+                const artifacts = idx === -1
+                    ? [...message.artifacts, artifact]
+                    : message.artifacts.map((a, i) => (i === idx ? { ...artifact, text: '' } : a));
+                return { ...message, artifacts };
+            }
+            if (idx === -1)
+                return message;
+            return {
+                ...message,
+                artifacts: message.artifacts.map((a, i) => i !== idx
+                    ? a
+                    : event.op === 'delta'
+                        ? { ...a, text: a.text + (event.text ?? '') }
+                        : { ...a, open: false }),
+            };
+        }
+        case 'ui':
+            return {
+                ...message,
+                ui: [
+                    ...message.ui,
+                    {
+                        callId: event.callId,
+                        uri: event.uri,
+                        html: event.html,
+                        preferredFrameSize: event.preferredFrameSize,
+                    },
+                ],
+            };
+        case 'file':
+            return message.files.some((f) => f.fileId === event.fileId)
+                ? message
+                : {
+                    ...message,
+                    files: [
+                        ...message.files,
+                        {
+                            fileId: event.fileId,
+                            name: event.name,
+                            mimeType: event.mimeType,
+                            bytes: event.bytes,
+                            path: event.path,
+                        },
+                    ],
+                };
+        case 'usage':
+            return {
+                ...message,
+                usage: {
+                    inputTokens: message.usage.inputTokens + event.inputTokens,
+                    outputTokens: message.usage.outputTokens + event.outputTokens,
+                    cacheReadTokens: message.usage.cacheReadTokens + (event.cacheReadTokens ?? 0),
+                    calls: message.usage.calls + 1,
+                },
+            };
+        case 'error':
+            return {
+                ...message,
+                status: 'error',
+                error: { code: event.code, message: event.message, retryable: event.retryable },
+            };
+        case 'done':
+            return {
+                ...message,
+                finishReason: event.finishReason,
+                status: message.status === 'error'
+                    ? 'error'
+                    : event.finishReason === 'cancelled'
+                        ? 'cancelled'
+                        : event.finishReason === 'length'
+                            ? 'incomplete'
+                            : 'done',
+            };
+    }
+}
+/** Human titles for client error codes (mirrors the task pane's wording). */
+export function errorTitle(code) {
+    const titles = {
+        bad_request: 'The request was not accepted',
+        unauthenticated: 'Sign in to continue',
+        forbidden: 'You do not have access to this',
+        not_found: 'Not found',
+        message_too_large: 'Message too long',
+        rate_limited: 'Too many requests; try again shortly',
+        upstream_unavailable: 'The agent is unavailable right now',
+        upstream_error: 'The agent ran into a problem',
+        timeout: 'The agent took too long',
+        cancelled: 'Stopped',
+        internal: 'Something went wrong',
+        network: 'Cannot reach Classic Agent',
+        protocol: 'Unexpected response from Classic Agent',
+    };
+    return titles[code];
+}

package/dist/reducer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=reducer.test.d.ts.map

package/dist/reducer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.test.d.ts","sourceRoot":"","sources":["../src/lib/reducer.test.ts"],"names":[],"mappings":""}

package/dist/reducer.test.js

@@ -0,0 +1,125 @@
+import { describe, expect, it } from 'vitest';
+import { applyEvent, errorTitle, newAssistantMessage, newUserMessage } from './reducer.js';
+const requestId = '11111111-1111-4111-8111-111111111111';
+const scope = { requestId, agent: 'classic-agent', runId: 'r1' };
+const ev = (e, seq) => ({ ...e, seq });
+describe('applyEvent', () => {
+    it('folds a full turn into the assistant message', () => {
+        const events = [
+            ev({ type: 'start', requestId, conversationId: 'c1', mode: 'mock' }, 0),
+            ev({ type: 'delegation', ...scope, child: 'company-data', childRunId: 'r2', status: 'start' }, 1),
+            ev({
+                type: 'tool_call',
+                requestId,
+                agent: 'company-data',
+                runId: 'r2',
+                parentRunId: 'r1',
+                callId: 'c1',
+                name: 'list_homes',
+                server: 'chapi',
+                argsPreview: '{}',
+            }, 2),
+            ev({
+                type: 'tool_result',
+                requestId,
+                agent: 'company-data',
+                runId: 'r2',
+                parentRunId: 'r1',
+                callId: 'c1',
+                status: 'ok',
+                durationMs: 5,
+                summary: '3 rows',
+            }, 3),
+            ev({
+                type: 'delegation',
+                ...scope,
+                child: 'company-data',
+                childRunId: 'r2',
+                status: 'end',
+                summary: 'done',
+            }, 4),
+            ev({ type: 'delta', requestId, text: 'Hello ' }, 5),
+            ev({
+                type: 'artifact',
+                ...scope,
+                artifactId: 'a1',
+                op: 'open',
+                mediaType: 'text/markdown',
+                title: 'Notes',
+            }, 6),
+            ev({ type: 'artifact', ...scope, artifactId: 'a1', op: 'delta', text: '# N' }, 7),
+            ev({ type: 'artifact', ...scope, artifactId: 'a1', op: 'close' }, 8),
+            ev({
+                type: 'ui',
+                ...scope,
+                callId: 'c2',
+                uri: 'ui://map/1',
+                mimeType: 'text/html',
+                html: '<p>m</p>',
+            }, 9),
+            ev({
+                type: 'file',
+                ...scope,
+                fileId: 'f1',
+                name: 'a.png',
+                mimeType: 'image/png',
+                bytes: 9,
+                path: '/api/files/f1',
+            }, 10),
+            ev({ type: 'usage', ...scope, model: 'm', inputTokens: 10, outputTokens: 2 }, 11),
+            ev({ type: 'delta', requestId, text: 'world' }, 12),
+            ev({ type: 'done', requestId, finishReason: 'stop' }, 13),
+        ];
+        const message = events.reduce(applyEvent, newAssistantMessage(requestId, 0));
+        expect(message).toMatchObject({
+            text: 'Hello world',
+            status: 'done',
+            mode: 'mock',
+            finishReason: 'stop',
+        });
+        expect(message.tools[0]).toMatchObject({
+            name: 'list_homes',
+            status: 'ok',
+            durationMs: 5,
+            summary: '3 rows',
+        });
+        expect(message.delegations).toEqual([
+            { child: 'company-data', childRunId: 'r2', status: 'end', summary: 'done' },
+        ]);
+        expect(message.artifacts[0]).toMatchObject({
+            artifactId: 'a1',
+            text: '# N',
+            open: false,
+            title: 'Notes',
+        });
+        expect(message.ui[0]).toMatchObject({ uri: 'ui://map/1' });
+        expect(message.files[0]).toMatchObject({ fileId: 'f1', path: '/api/files/f1' });
+        expect(message.usage).toEqual({
+            inputTokens: 10,
+            outputTokens: 2,
+            cacheReadTokens: 0,
+            calls: 1,
+        });
+    });
+    it('marks errors, cancellations and truncation', () => {
+        const base = newAssistantMessage(requestId, 0);
+        const errored = applyEvent(applyEvent(base, ev({ type: 'error', requestId, code: 'timeout', message: 'slow', retryable: true }, 1)), ev({ type: 'done', requestId, finishReason: 'error' }, 2));
+        expect(errored).toMatchObject({ status: 'error', error: { code: 'timeout', retryable: true } });
+        expect(applyEvent(base, ev({ type: 'done', requestId, finishReason: 'cancelled' }, 1)).status).toBe('cancelled');
+        expect(applyEvent(base, ev({ type: 'done', requestId, finishReason: 'length' }, 1)).status).toBe('incomplete');
+        expect(errorTitle('network')).toMatch(/Cannot reach/);
+    });
+    it('labels user context', () => {
+        const user = newUserMessage(requestId, 'hi', {
+            context: {
+                host: 'app',
+                capturedAt: '2026-10-30T00:00:00.000Z',
+                route: '/sales/homes/1',
+                title: 'Home 1',
+                record: { kind: 'home', id: '1', label: 'Lot 12' },
+            },
+            now: 0,
+        });
+        expect(user.contextLabel).toBe('Lot 12');
+    });
+});

package/dist/session.svelte.d.ts

@@ -0,0 +1,55 @@
+import type { AgentApiClient } from '@classic-homes/agent-client';
+import type { AgentKey, BackendMode, ChatEvent, ClientKind, DocumentContext, FileRef } from '@classic-homes/agent-contracts';
+import { type AssistantMessage, type ChatMessage } from './reducer.js';
+export interface ChatSessionOptions {
+    client: AgentApiClient;
+    conversationId?: string | null;
+    /** Backend mode known before the first turn (from `/api/me`), so the mock banner shows at once. */
+    mode?: BackendMode;
+    agent?: AgentKey;
+    clientKind?: ClientKind;
+    /** Context attached to each turn when the host's toggle is on. */
+    getContext?: () => DocumentContext | null | undefined;
+    onConversationStarted?: (conversationId: string) => void;
+    onToolResult?: (name: string, status: string) => void;
+    onEvent?: (event: ChatEvent) => void;
+}
+export type SessionStatus = 'idle' | 'loading' | 'streaming';
+/**
+ * Reactive conversation state (Svelte 5 runes class). Owns the stream lifecycle: one turn at a
+ * time, cancel, resume after reload, history load. Rendering is left to the components.
+ */
+export declare class ChatSession {
+    messages: ChatMessage[];
+    status: SessionStatus;
+    conversationId: string | null;
+    /** The conversation whose transcript `messages` holds (loaded or started here); null before. */
+    loadedConversationId: string | null;
+    mode: "mock" | "live" | undefined;
+    loadError: string | undefined;
+    pendingFiles: {
+        fileId: string;
+        name: string;
+        mimeType: string;
+        bytes: number;
+        status: "uploaded" | "indexed" | "failed";
+    }[];
+    private controller;
+    private readonly options;
+    constructor(options: ChatSessionOptions);
+    get streaming(): boolean;
+    get current(): AssistantMessage | undefined;
+    /** Load an existing conversation's transcript and re-attach to a running turn if any. */
+    load(conversationId: string): Promise<void>;
+    send(text: string, options?: {
+        files?: FileRef[];
+    }): Promise<void>;
+    /** Re-attach to a turn after reload: replays events after the last seq we hold (none here). */
+    resume(requestId: string): Promise<void>;
+    cancel(): void;
+    private run;
+    private toolName;
+    private update;
+}
+export declare function createChatSession(options: ChatSessionOptions): ChatSession;
+//# sourceMappingURL=session.svelte.d.ts.map

package/dist/session.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.svelte.d.ts","sourceRoot":"","sources":["../src/lib/session.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAElE,OAAO,KAAK,EACV,QAAQ,EACR,WAAW,EACX,SAAS,EAET,UAAU,EACV,eAAe,EACf,OAAO,EACR,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAIL,KAAK,gBAAgB,EACrB,KAAK,WAAW,EACjB,MAAM,cAAc,CAAC;AAEtB,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,cAAc,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,mGAAmG;IACnG,IAAI,CAAC,EAAE,WAAW,CAAC;IACnB,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,kEAAkE;IAClE,UAAU,CAAC,EAAE,MAAM,eAAe,GAAG,IAAI,GAAG,SAAS,CAAC;IACtD,qBAAqB,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IACzD,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;IACtD,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,KAAK,IAAI,CAAC;CACtC;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,SAAS,GAAG,WAAW,CAAC;AAE7D;;;GAGG;AACH,qBAAa,WAAW;IACtB,QAAQ,gBAA6B;IACrC,MAAM,gBAAiC;IACvC,cAAc,gBAA+B;IAC7C,gGAAgG;IAChG,oBAAoB,gBAA+B;IACnD,IAAI,8BAA8C;IAClD,SAAS,qBAAyC;IAClD,YAAY;;;;;;QAAyB;IAErC,OAAO,CAAC,UAAU,CAA8B;IAChD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;gBAEjC,OAAO,EAAE,kBAAkB;IAMvC,IAAI,SAAS,IAAI,OAAO,CAEvB;IAED,IAAI,OAAO,IAAI,gBAAgB,GAAG,SAAS,CAG1C;IAED,yFAAyF;IACnF,IAAI,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA+B3C,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,OAAO,EAAE,CAAA;KAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IA0B5E,+FAA+F;IACzF,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAa9C,MAAM,IAAI,IAAI;YAOA,GAAG;IAmDjB,OAAO,CAAC,QAAQ;IAOhB,OAAO,CAAC,MAAM;CAKf;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,kBAAkB,GAAG,WAAW,CAE1E"}

package/dist/session.svelte.js

@@ -0,0 +1,157 @@
+import { ApiRequestError } from '@classic-homes/agent-client';
+import { applyEvent, newAssistantMessage, newUserMessage, } from './reducer.js';
+/**
+ * Reactive conversation state (Svelte 5 runes class). Owns the stream lifecycle: one turn at a
+ * time, cancel, resume after reload, history load. Rendering is left to the components.
+ */
+export class ChatSession {
+    messages = $state([]);
+    status = $state('idle');
+    conversationId = $state(null);
+    /** The conversation whose transcript `messages` holds (loaded or started here); null before. */
+    loadedConversationId = $state(null);
+    mode = $state(undefined);
+    loadError = $state(undefined);
+    pendingFiles = $state([]);
+    controller;
+    options;
+    constructor(options) {
+        this.options = options;
+        this.conversationId = options.conversationId ?? null;
+        this.mode = options.mode;
+    }
+    get streaming() {
+        return this.status === 'streaming';
+    }
+    get current() {
+        const last = this.messages[this.messages.length - 1];
+        return last?.role === 'assistant' ? last : undefined;
+    }
+    /** Load an existing conversation's transcript and re-attach to a running turn if any. */
+    async load(conversationId) {
+        this.status = 'loading';
+        this.loadError = undefined;
+        try {
+            const detail = await this.options.client.getConversation(conversationId);
+            this.conversationId = conversationId;
+            this.loadedConversationId = conversationId;
+            this.messages = detail.messages.map((m) => m.role === 'user'
+                ? {
+                    id: m.id,
+                    role: 'user',
+                    text: m.content.map((c) => c.text).join('\n'),
+                    attachments: [],
+                    createdAt: m.createdAt,
+                }
+                : {
+                    ...newAssistantMessage(m.id.replace(/^a-/, ''), m.createdAt),
+                    text: m.content.map((c) => c.text).join('\n'),
+                    status: 'done',
+                });
+            const active = detail.conversation.activeRequestId;
+            this.status = 'idle';
+            if (active)
+                await this.resume(active);
+        }
+        catch (err) {
+            this.status = 'idle';
+            this.loadError = err instanceof Error ? err.message : 'Could not load the conversation';
+        }
+    }
+    async send(text, options = {}) {
+        const message = text.trim();
+        if (!message || this.status !== 'idle')
+            return;
+        const requestId = crypto.randomUUID();
+        const context = this.options.getContext?.() ?? undefined;
+        const files = options.files ?? this.pendingFiles;
+        this.pendingFiles = [];
+        const request = {
+            requestId,
+            agent: this.options.agent ?? 'classic-agent',
+            message,
+            ...(this.conversationId ? { conversationId: this.conversationId } : {}),
+            ...(context ? { context } : {}),
+            ...(files.length ? { fileIds: files.map((f) => f.fileId) } : {}),
+            ...(this.options.clientKind ? { client: this.options.clientKind } : {}),
+        };
+        this.messages = [
+            ...this.messages,
+            newUserMessage(requestId, message, { attachments: files, context }),
+            newAssistantMessage(requestId),
+        ];
+        await this.run(requestId, (signal, onEvent) => this.options.client.streamChat(request, { signal, onEvent }));
+    }
+    /** Re-attach to a turn after reload: replays events after the last seq we hold (none here). */
+    async resume(requestId) {
+        if (!this.conversationId || this.status !== 'idle')
+            return;
+        if (!this.messages.some((m) => m.role === 'assistant' && m.requestId === requestId)) {
+            this.messages = [...this.messages, newAssistantMessage(requestId)];
+        }
+        else {
+            this.update(requestId, (m) => ({ ...m, status: 'streaming', text: '' }));
+        }
+        const conversationId = this.conversationId;
+        await this.run(requestId, (signal, onEvent) => this.options.client.resumeTurn(conversationId, requestId, -1, { signal, onEvent }));
+    }
+    cancel() {
+        const current = this.current;
+        if (!this.controller || !current)
+            return;
+        this.controller.abort();
+        void this.options.client.cancel(current.requestId);
+    }
+    async run(requestId, start) {
+        this.status = 'streaming';
+        this.controller = new AbortController();
+        const onEvent = (event) => {
+            if (event.type === 'start') {
+                this.mode = event.mode;
+                if (this.conversationId !== event.conversationId) {
+                    this.conversationId = event.conversationId;
+                    this.loadedConversationId = event.conversationId;
+                    this.options.onConversationStarted?.(event.conversationId);
+                }
+            }
+            if (event.type === 'tool_result')
+                this.options.onToolResult?.(this.toolName(requestId, event.callId), event.status);
+            this.update(requestId, (m) => applyEvent(m, event));
+            this.options.onEvent?.(event);
+        };
+        try {
+            const outcome = await start(this.controller.signal, onEvent);
+            if (outcome.kind === 'aborted')
+                this.update(requestId, (m) => m.status === 'streaming' ? { ...m, status: 'cancelled', finishReason: 'cancelled' } : m);
+            else if (outcome.kind === 'ended')
+                this.update(requestId, (m) => m.status === 'streaming' ? { ...m, status: 'incomplete' } : m);
+        }
+        catch (err) {
+            const code = err instanceof ApiRequestError ? err.code : 'network';
+            const text = err instanceof Error ? err.message : 'The request failed';
+            this.update(requestId, (m) => ({
+                ...m,
+                status: 'error',
+                error: {
+                    code,
+                    message: text,
+                    retryable: err instanceof ApiRequestError ? err.retryable : true,
+                },
+            }));
+        }
+        finally {
+            this.controller = undefined;
+            this.status = 'idle';
+        }
+    }
+    toolName(requestId, callId) {
+        const m = this.messages.find((x) => x.role === 'assistant' && x.requestId === requestId);
+        return m?.tools.find((t) => t.callId === callId)?.name ?? '';
+    }
+    update(requestId, fn) {
+        this.messages = this.messages.map((m) => m.role === 'assistant' && m.requestId === requestId ? fn(m) : m);
+    }
+}
+export function createChatSession(options) {
+    return new ChatSession(options);
+}