quassel 0.1.0

package/server/types.d.ts

@@ -0,0 +1,62 @@
+import { ChatEvent } from "../events";
+/** Konfiguration gegen ein OpenAI-kompatibles Backend (OpenRouter, Ollama, vLLM, ...). */
+export interface AgentConfig {
+    baseUrl: string;
+    model: string;
+    apiKey?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    topP?: number;
+    maxTokens?: number;
+    headers?: Record<string, string>;
+    tools?: AgentTool[];
+}
+export interface AgentTool {
+    name: string;
+    description: string;
+    parameters: object;
+    run: (args: unknown) => Promise<string> | string;
+}
+export interface OpenAiToolCall {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface OpenAiMessage {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | null;
+    tool_calls?: OpenAiToolCall[];
+    tool_call_id?: string;
+}
+export interface SessionState {
+    id: string;
+    events: ChatEvent[];
+    history: OpenAiMessage[];
+    updatedAt: number;
+}
+export interface SessionInfo {
+    id: string;
+    title: string;
+    updatedAt: number;
+}
+/** Was der HTTP-Adapter von einer Unterhaltung braucht - AgentSession erfüllt das, andere Backends auch. */
+export interface ChatSessionLike {
+    readonly running: boolean;
+    subscribe(listener: (event: import("../events").ChatEvent) => void): () => void;
+    send(text: string): void;
+    stop(): void;
+}
+export interface ChatSessionProvider {
+    get(id: string): Promise<ChatSessionLike>;
+    list(): Promise<SessionInfo[]>;
+    delete(id: string): Promise<void>;
+}
+export interface SessionStore {
+    load(id: string): Promise<SessionState | undefined>;
+    save(state: SessionState): Promise<void>;
+    list(): Promise<SessionInfo[]>;
+    delete(id: string): Promise<void>;
+}

package/texts.d.ts

@@ -0,0 +1,39 @@
+export interface ChatTexts {
+    working: string;
+    toolRunning: string;
+    toolStillRunning: string;
+    thinkingChip: string;
+    stepGroupOne: string;
+    stepGroupMany: string;
+    stepGroupCollapse: string;
+    thinkingTitle: string;
+    toolTitle: string;
+    argumentsLabel: string;
+    resultLabel: string;
+    close: string;
+    jumpToEnd: string;
+    send: string;
+    sendIntoRun: string;
+    stop: string;
+    placeholder: string;
+    steeringPlaceholder: string;
+    timestamps: string;
+    messageActions: string;
+    questionSubmit: string;
+    questionPlaceholder: string;
+    questionAnswer: string;
+    copyMessage: string;
+    copyCode: string;
+    copied: string;
+    copyFailed: string;
+    editMessage: string;
+    retryMessage: string;
+    detailModeTitle: string;
+    detailModeOff: string;
+    detailModeIcons: string;
+    detailModeChips: string;
+    detailModeGrouped: string;
+    detailModeCompact: string;
+    detailModeFull: string;
+}
+export declare const defaultTexts: ChatTexts;

package/timestamps.d.ts

@@ -0,0 +1,5 @@
+import type { TimestampOptions } from "./options";
+export declare function timestampDate(at?: string): Date | undefined;
+export declare function formatTimestamp(date: Date, options?: TimestampOptions, now?: number): string;
+export declare function timestampDay(date: Date, timeZone?: string): string;
+export declare function formatDay(date: Date, options?: TimestampOptions): string;

package/types.d.ts

@@ -0,0 +1,22 @@
+import type { Message } from "./events";
+export type { Role, ToolInfo, Question, Message, ChatEvent } from "./events";
+export { applyEvent, prettyJson, compactToolLine } from "./events";
+/**
+ * off = nur Antworten, icons = Schritte als reine Symbole nebeneinander,
+ * chips = Schritte als Symbol + Kurztext nebeneinander (mit Umbruch),
+ * grouped = aufeinanderfolgende Schritte hinter einer aufklappbaren Kopfzeile, darin einzeilig,
+ * compact = Denken und Werkzeuge einzeilig, full = alles ausgeklappt.
+ */
+export type DetailMode = "off" | "icons" | "chips" | "grouped" | "compact" | "full";
+/** running = call still open, thinking = thought block still open, done = finished, error = failed. */
+export type StepState = "running" | "thinking" | "done" | "error";
+/** The single derivation of a step state, so chips, hosts and tests read the same signal. */
+export declare function stepState(message: Message): StepState;
+/** A moment worth one screen reader announcement: a finished reply or a new open question. */
+export type ChatAnnouncement = {
+    kind: "reply";
+    message: Message;
+} | {
+    kind: "question";
+    message: Message;
+};

package/useChat.d.ts

@@ -0,0 +1,14 @@
+import { ChatEvent, Message } from "./events";
+/**
+ * Verbindet die Chat-Komponenten mit einem quassel/server-Endpunkt: ein dauerhafter
+ * SSE-Strom liefert erst den Verlauf, dann live; Senden und Stoppen sind eigene Aufrufe
+ * und erreichen so auch einen laufenden Turn. Bricht der Strom ab, verbindet der Hook
+ * nach 3 Sekunden neu.
+ */
+export declare function useChat(baseUrl: string, headers?: Record<string, string>, onEvent?: (event: ChatEvent) => void): {
+    messages: Message[];
+    running: boolean;
+    connected: boolean;
+    send: (text: string) => Promise<void>;
+    stop: () => Promise<void>;
+};