@adaptiqai/deepseek-harness 0.0.0-stage → 0.2.2

package/lib/types/client/model.d.ts

@@ -0,0 +1,37 @@
+import type { AccountSnapshot, SessionView } from '@adaptiqai/core/types';
+import type { Kit, ModelChoice } from './actions.ts';
+/** The harness's standard projection hook on session-scoped slots. */
+export type UseProjection = (key: string) => unknown;
+/**
+ * The composer's next model and the one the conversation last ran on.
+ * @param useProjection - the slot's standard hook, when the harness passes it.
+ * @returns both, or undefined while unknown.
+ */
+export declare function useSelection(kit: Kit, sessionId: string, useProjection: UseProjection | undefined): {
+    next: ModelChoice | null;
+    lastUsed: ModelChoice | null;
+} | undefined;
+/**
+ * Report the conversation's AdaptiqAI model to the Host, which keeps knowledge
+ * and memory on the right model before the first message is sent.
+ * @param kit - plugin kit.
+ * @param sessionId - harness session id.
+ * @param account - account snapshot (gives the route).
+ * @param useProjection - the slot's standard projection hook.
+ */
+export declare function useReportChoice(kit: Kit, sessionId: string, account: AccountSnapshot | null, useProjection: UseProjection | undefined): void;
+/**
+ * Whether the conversation's memory lives on a model other than the one chosen.
+ * @param view - conversation view.
+ * @param choice - composer choice.
+ * @param route - this plugin's provider route.
+ * @returns true when sending now would leave the memory behind.
+ */
+export declare function memoryElsewhere(view: SessionView | null, choice: ModelChoice | null | undefined, route: string | undefined): boolean;
+/**
+ * A model's display name.
+ * @param account - account snapshot.
+ * @param id - model id.
+ * @returns the name.
+ */
+export declare function modelLabel(account: AccountSnapshot | null, id: string): string;

package/lib/types/client/store.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Browser-side state: observable snapshots fed by the Host's `adaptiq`
+ * Remote streams, plus typed calls. Components read stores through the slot
+ * framework's `use<Name>` hooks; nothing here touches React.
+ */
+import type { AccountSnapshot, ConversationPage, CreateKnowledgeInput, CreateKnowledgeResult, DiagnosticsView, KnowledgePage, MakeAvailableResult, Preferences, PurchaseView, SessionView, SignInStart } from '@adaptiqai/core/types';
+/** The observable contract the slot framework binds to `use<Name>` hooks. */
+export interface Observable<T> {
+    getSnapshot(): T;
+    subscribe(listener: () => void): () => void;
+}
+/** A writable observable. */
+export interface Store<T> extends Observable<T> {
+    set(value: T): void;
+}
+/**
+ * A store that starts its source with the first subscriber and stops it a
+ * little after the last one leaves (a remount does not reopen the stream).
+ * @param initial - value before the source answers.
+ * @param start - open the source; return its stop function.
+ * @returns the store.
+ */
+export declare function lazyStore<T>(initial: T, start?: (set: (value: T) => void) => () => void): Store<T>;
+/** One Remote call result as the client runtime returns it. */
+type RemoteResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: Error & {
+        code?: string;
+        details?: {
+            code?: string;
+            status?: number | null;
+        };
+    };
+};
+/** The `adaptiq` namespace as mounted on `ctx.remote`. */
+export interface AdaptiqRemote {
+    getState(): Promise<RemoteResult<AccountSnapshot>>;
+    watch(signal?: AbortSignal): AsyncIterable<AccountSnapshot> & {
+        dispose(): void;
+    };
+    startSignIn(): Promise<RemoteResult<SignInStart>>;
+    cancelSignIn(): Promise<RemoteResult<void>>;
+    signOut(): Promise<RemoteResult<void>>;
+    refresh(): Promise<RemoteResult<AccountSnapshot>>;
+    setPreferences(patch: Partial<Preferences>): Promise<RemoteResult<Preferences>>;
+    dismissNotice(id: string): Promise<RemoteResult<void>>;
+    getSession(sessionId: string): Promise<RemoteResult<SessionView>>;
+    watchSession(sessionId: string, signal?: AbortSignal): AsyncIterable<SessionView> & {
+        dispose(): void;
+    };
+    setRemember(sessionId: string, remember: boolean): Promise<RemoteResult<SessionView>>;
+    setSessionModel(sessionId: string, model?: string, lastUsed?: string): Promise<RemoteResult<SessionView>>;
+    makeKnowledgeAvailable(id: string, from: string, sessionId?: string): Promise<RemoteResult<MakeAvailableResult>>;
+    startPurchase(offerId: string, lanes: number): Promise<RemoteResult<PurchaseView>>;
+    checkPurchase(): Promise<RemoteResult<void>>;
+    cancelPurchase(): Promise<RemoteResult<void>>;
+    dismissPurchase(): Promise<RemoteResult<void>>;
+    listConversations(sessionId: string, query?: string, cursor?: string): Promise<RemoteResult<ConversationPage>>;
+    attachConversation(sessionId: string, conversationId: string): Promise<RemoteResult<SessionView>>;
+    detachConversation(sessionId: string, conversationId: string): Promise<RemoteResult<SessionView>>;
+    listKnowledge(query?: string, cursor?: string, sessionId?: string, model?: string): Promise<RemoteResult<KnowledgePage>>;
+    attachKnowledge(sessionId: string, id: string): Promise<RemoteResult<SessionView>>;
+    detachKnowledge(sessionId: string, id: string): Promise<RemoteResult<SessionView>>;
+    createKnowledge(input: CreateKnowledgeInput): Promise<RemoteResult<CreateKnowledgeResult>>;
+    openExternal(url: string): Promise<RemoteResult<boolean>>;
+    diagnostics(): Promise<RemoteResult<DiagnosticsView>>;
+}
+/** The client context slice this plugin uses. */
+export interface ClientRemote {
+    readonly adaptiq: AdaptiqRemote;
+    readonly $host?: {
+        readonly isLoopback?: boolean;
+        readonly home?: string;
+    };
+}
+/**
+ * Unwrap a Remote result: the error branch becomes a thrown Error with a
+ * readable message.
+ * @param pending - the Remote call.
+ * @returns the value.
+ */
+export declare function unwrap<T>(pending: Promise<RemoteResult<T>>): Promise<T>;
+/**
+ * Keep a Remote stream open: reopen it after a carrier loss with backoff.
+ * @param open - open one stream.
+ * @param onValue - receives every value.
+ * @param onDown - the stream is reconnecting.
+ * @returns stop.
+ */
+export declare function followStream<T>(open: () => AsyncIterable<T> & {
+    dispose(): void;
+}, onValue: (value: T) => void, onDown?: () => void): () => void;
+/** Shared client state for every component of the plugin. */
+export interface ClientState {
+    readonly account: Store<AccountSnapshot | null>;
+    session(sessionId: string): Store<SessionView | null>;
+    /** The conversation whose composer was shown most recently (the Knowledge page acts on it). */
+    readonly activeSession: Store<string | null>;
+    /** Last-turn flashes: sessionId → time the pill should show "from memory" until. */
+    dispose(): void;
+}
+/**
+ * Create the client state over the mounted Remote.
+ * @param remote - `ctx.remote`.
+ * @param onReset - subscribe to connection resets (reopen streams).
+ * @returns the state.
+ */
+export declare function createClientState(remote: ClientRemote, onReset: (listener: () => void) => () => void): ClientState;
+export {};

package/lib/types/client/styles/fonts.d.ts

@@ -0,0 +1 @@
+export declare const FONT_CSS: string;

package/lib/types/client/ui.d.ts

@@ -0,0 +1,69 @@
+/** AdaptiqAI building blocks: the cairn, the lockup, icons, meters and overlays. */
+import { type ReactNode } from 'react';
+import { formatTokens } from '@adaptiqai/core/format';
+/** Translate with the plugin's dictionary. */
+export type T = (key: string, params?: Record<string, unknown>) => string;
+/** The cairn: three coral stones under one ink stone. */
+export declare function Cairn({ size, alive, onDark }: {
+    size?: number;
+    alive?: boolean;
+    onDark?: boolean;
+}): import("react").JSX.Element;
+/** The AdaptiqAI wordmark in the current text colour. */
+export declare function Wordmark({ height }: {
+    height?: number;
+}): import("react").JSX.Element;
+declare const PATHS: Record<string, ReactNode>;
+/** A stroke icon in the Lucide geometry the Knowledge app uses. */
+export declare function Icon({ name, size }: {
+    name: keyof typeof PATHS | string;
+    size?: number;
+}): import("react").JSX.Element;
+/** A progress ring. */
+export declare function Ring({ fraction, size, stroke }: {
+    fraction: number;
+    size?: number;
+    stroke?: number;
+}): import("react").JSX.Element;
+/** A segmented usage bar. */
+export declare function UsageBar({ segments, warn, thin }: {
+    segments: readonly {
+        cls: string;
+        fraction: number;
+    }[];
+    warn?: boolean;
+    thin?: boolean;
+}): import("react").JSX.Element;
+/** Compact token text. */
+export declare const tokens: typeof formatTokens;
+/** Render into document.body inside an `.aq` scope (so tokens and dark mode apply). */
+export declare function Portal({ children, className }: {
+    children: ReactNode;
+    className: string;
+}): import("react").ReactPortal;
+/** A centred modal with scrim, Escape and focus handling. */
+export declare function Modal({ onClose, children, label }: {
+    onClose: () => void;
+    children: ReactNode;
+    label: string;
+}): import("react").JSX.Element;
+/** Copy text and say so for a moment. */
+export declare function useCopy(): [boolean, (text: string) => void];
+/** Re-render every `ms` (relative times, countdowns). */
+export declare function useTick(ms: number): number;
+/**
+ * "just now" / "4 min ago" / a date.
+ * @param t - translate.
+ * @param at - time in ms.
+ * @param now - current time.
+ * @returns relative text.
+ */
+export declare function relative(t: T, at: number, now: number): string;
+/** Run a promise-returning action with busy and error state. */
+export declare function useAction(): {
+    busy: boolean;
+    error: string | null;
+    run: (work: () => Promise<unknown>) => Promise<boolean>;
+    clear: () => void;
+};
+export {};

package/lib/types/host/adapter.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The AdaptiqAI model provider: a harness LlmAdapter over the OpenAI-compatible
+ * AdaptiqAI API. Models, their windows, thinking levels and sampling defaults
+ * come from the workspace catalog; requests carry the harness session id so
+ * the server keeps one native memory per conversation.
+ */
+import { LlmAdapter, LlmError } from '@deepseek-ai/dsh-llm';
+import type { GenerateOptions, LlmModelInfo, LlmProviderInfo, LlmResolvedModelInfo, PreparedAdapterCall, ResolvedRetryPolicy, StreamChunk } from '@deepseek-ai/dsh-llm';
+import { type AdaptiqFailure, type AuthManager, type CatalogModel, type RequestEvents } from '@adaptiqai/core';
+/** What the adapter tells the rest of the plugin about each request. */
+export interface AdapterDeps {
+    readonly route: string;
+    readonly displayName: string;
+    readonly apiBase: string;
+    readonly pluginVersion: string;
+    readonly progressEvents: boolean;
+    readonly idleTimeoutMs: number;
+    readonly auth: AuthManager;
+    /** The current catalog (may be empty before the first refresh). */
+    models(): readonly CatalogModel[];
+    /** The catalog, refreshed first when empty or stale. */
+    ensureModels(signal?: AbortSignal): Promise<readonly CatalogModel[]>;
+    /** A request named a model the server no longer offers: refresh soon. */
+    modelMissing(id: string): void;
+    /** Whether new messages of this conversation are saved to memory. */
+    remember(sessionId: string | undefined): boolean;
+    /** Whether the server already stores this conversation (may look it up first). */
+    stored(sessionId: string | undefined): boolean | Promise<boolean>;
+    readonly events: RequestEvents;
+    readonly fetch?: typeof fetch;
+}
+/** The harness retries busy and preparing answers itself, honouring Retry-After. */
+export declare const RETRY_POLICY: ResolvedRetryPolicy;
+/**
+ * Exact-route model info the harness reads (context window, efforts, output default).
+ * @param route - provider route id.
+ * @param model - catalog entry.
+ * @returns the resolved info.
+ */
+export declare function resolvedInfo(route: string, model: CatalogModel): LlmResolvedModelInfo;
+/** An LlmError whose code and facts the harness routes on. */
+export declare function toLlmError(failure: AdaptiqFailure, cause?: unknown): LlmError;
+export declare class AdaptiqAdapter extends LlmAdapter {
+    private readonly deps;
+    private readonly fetch;
+    constructor(deps: AdapterDeps);
+    providerInfo(provider: string): LlmProviderInfo;
+    providerRetryPolicy(): ResolvedRetryPolicy;
+    listModels(provider: string): Promise<readonly LlmModelInfo[]>;
+    resolveModel(provider: string, model: string, signal?: AbortSignal): Promise<LlmResolvedModelInfo>;
+    prepareCall(provider: string, model: string, signal?: AbortSignal): Promise<PreparedAdapterCall>;
+    stream(options: GenerateOptions): AsyncIterable<StreamChunk>;
+    private generate;
+}

package/lib/types/host/commands.d.ts

@@ -0,0 +1,17 @@
+/** `/adaptiq`: status, sign-in, privacy and knowledge from the composer, in plain text. */
+import type { Context } from '@deepseek-ai/cordis';
+import { type AuthManager, type Workspace } from '@adaptiqai/core';
+/**
+ * The action word of `/adaptiq …`, however the composer passes it: with or
+ * without the command name, a leading slash, or a completion glued on with "/".
+ * @param rawInput - text after (or including) the command name.
+ * @returns the action, lower case; "" for none.
+ */
+export declare function commandAction(rawInput: string): string;
+/**
+ * Register `/adaptiq`.
+ * @param ctx - context with the `commands` service.
+ * @param workspace - the workspace.
+ * @param auth - the sign-in owner.
+ */
+export declare function registerCommand(ctx: Context, workspace: Workspace, auth: AuthManager): void;

package/lib/types/host/config.d.ts

@@ -0,0 +1,33 @@
+/** Plugin configuration: everything has a production default, nothing names a model. */
+import z from '@deepseek-ai/schemastery';
+export interface Config {
+    /** AdaptiqAI API origin (the OpenAI-compatible API lives under `/v1`). */
+    apiBase: string;
+    /** The AdaptiqAI knowledge console. */
+    consoleUrl: string;
+    /** Provider route id the models appear under in the model picker. */
+    route: string;
+    /** Provider name in the model picker. */
+    displayName: string;
+    /** Credential reference holding an API key for headless use (`ak_live_…`). Optional when signed in. */
+    apiKeyEnv: string;
+    /** Seconds between catalog refreshes while the harness runs. */
+    catalogRefreshSeconds: number;
+    /** Seconds between account/lane/memory refreshes while someone is watching. */
+    accountRefreshSeconds: number;
+    /** Seconds a stream may stay silent before the request counts as stalled. */
+    streamIdleTimeoutSeconds: number;
+    /** Register the adaptiq_knowledge, adaptiq_memory and adaptiq_create_knowledge agent tools. */
+    tools: boolean;
+    /** Look up newer plugin versions on the npm registry (once a day). */
+    updateCheck: boolean;
+    /** Ask the server for streamed progress while a long conversation is prepared. */
+    progressEvents: boolean;
+}
+export declare const Config: z<Config>;
+/**
+ * Normalise the configured API origin: no trailing slash and no `/v1`.
+ * @param value - configured origin, possibly with `/v1`.
+ * @returns the origin without a trailing `/v1`.
+ */
+export declare function apiOrigin(value: string): string;

package/lib/types/host/controller.d.ts

@@ -0,0 +1,85 @@
+/**
+ * The `adaptiq` Remote namespace: what the browser half may ask the Host.
+ * Tokens never cross it; every method answers with plain snapshots.
+ * scripts/remote-spec.mjs lists the same methods for the Typert artifacts.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import { type AccountSnapshot, type AuthManager, type CreateKnowledgeInput, type CreateKnowledgeResult, type DiagnosticsView, type KnowledgePage, type ConversationPage, type MakeAvailableResult, type Preferences, type PurchaseView, type SessionView, type SignInStart, type Workspace } from '@adaptiqai/core';
+declare module '@deepseek-ai/dsh-typert-protocol' {
+    interface RemoteErrorDetailsMap {
+        /** An AdaptiqAI call failed; `code` is the plugin's stable failure code. */
+        'adaptiq/failed': {
+            readonly code: string;
+            readonly status: number | null;
+        };
+    }
+}
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        adaptiqController: AdaptiqController;
+    }
+}
+/** What the controller works on. */
+export interface ControllerDeps {
+    readonly workspace: Workspace;
+    readonly auth: AuthManager;
+}
+/** AdaptiqAI account, memory and knowledge for the browser half of the AdaptiqAI plugin. */
+export declare class AdaptiqController extends TypertRemoteService {
+    private readonly deps;
+    static inject: string[];
+    constructor(ctx: Context, deps: ControllerDeps);
+    /** Read the current account snapshot. */
+    getState(): Promise<AccountSnapshot>;
+    /** Follow the account snapshot: the current one, then every change. */
+    watch(signal: AbortSignal): AsyncIterable<AccountSnapshot>;
+    /** Start a browser sign-in and return the approval link and code. */
+    startSignIn(): Promise<SignInStart>;
+    /** Stop waiting for a browser approval. */
+    cancelSignIn(): Promise<void>;
+    /** Forget the saved AdaptiqAI connection on this computer. */
+    signOut(): Promise<void>;
+    /** Re-read the workspace, its models, lanes and memory now. */
+    refresh(): Promise<AccountSnapshot>;
+    /** Change saved plugin preferences. */
+    setPreferences(patch: Partial<Preferences>): Promise<Preferences>;
+    /** Take one notice down. */
+    dismissNotice(id: string): Promise<void>;
+    /** Read one conversation's memory and knowledge. */
+    getSession(sessionIdValue: string): Promise<SessionView>;
+    /** Follow one conversation's memory and request state. */
+    watchSession(sessionIdValue: string, signal: AbortSignal): AsyncIterable<SessionView>;
+    /** Choose whether new messages in this conversation are saved to memory. */
+    setRemember(sessionIdValue: string, remember: boolean): Promise<SessionView>;
+    /** Tell the plugin which AdaptiqAI model this conversation has selected (none for another provider) and which one it last ran on. */
+    setSessionModel(sessionIdValue: string, model?: string, lastUsed?: string): Promise<SessionView>;
+    /** Search the workspace knowledge library. */
+    listKnowledge(query?: string, cursor?: string, sessionIdValue?: string, model?: string): Promise<KnowledgePage>;
+    /** Make a collection built for another model available for the model this conversation uses. */
+    makeKnowledgeAvailable(id: string, from: string, sessionIdValue?: string): Promise<MakeAvailableResult>;
+    /** Start getting lanes on a model: the person confirms (and pays) in the browser. */
+    startPurchase(offerId: string, lanes: number): Promise<PurchaseView>;
+    /** Check the purchase in progress now. */
+    checkPurchase(): Promise<void>;
+    /** Stop following the purchase in progress. */
+    cancelPurchase(): Promise<void>;
+    /** Put away a finished purchase. */
+    dismissPurchase(): Promise<void>;
+    /** Saved conversations on the model this conversation uses, newest first. */
+    listConversations(sessionIdValue: string, query?: string, cursor?: string): Promise<ConversationPage>;
+    /** Let this conversation read another one. */
+    attachConversation(sessionIdValue: string, conversationId: string): Promise<SessionView>;
+    /** Stop reading another conversation. */
+    detachConversation(sessionIdValue: string, conversationId: string): Promise<SessionView>;
+    /** Use one collection in this conversation. */
+    attachKnowledge(sessionIdValue: string, id: string): Promise<SessionView>;
+    /** Stop using one collection in this conversation. */
+    detachKnowledge(sessionIdValue: string, id: string): Promise<SessionView>;
+    /** Create a collection from files, text or links. */
+    createKnowledge(input: CreateKnowledgeInput): Promise<CreateKnowledgeResult>;
+    /** Open an AdaptiqAI page in the default browser. */
+    openExternal(url: string): Promise<boolean>;
+    /** A secret-free report of the connection and recent failures. */
+    diagnostics(): Promise<DiagnosticsView>;
+}

package/lib/types/host/index.d.ts

@@ -0,0 +1,12 @@
+import type { Context } from '@deepseek-ai/cordis';
+import { Config } from './config.ts';
+export { Config };
+export declare const name = "adaptiq";
+export declare const inject: string[];
+export declare const usage = "\nAdaptiqAI models with native memory, signed in with your AdaptiqAI account.\nOpen **Settings \u2192 AdaptiqAI** to connect, or run `/adaptiq signin`.\n";
+/**
+ * Mount the plugin.
+ * @param ctx - the plugin context.
+ * @param config - resolved configuration.
+ */
+export declare function apply(ctx: Context, config: Config): Promise<void>;

package/lib/types/host/stores.d.ts

@@ -0,0 +1,27 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { CredentialStore, StateStore } from '@adaptiqai/core';
+/** The harness credential record holding the workspace grant. */
+export declare const GRANT_KEY: {
+    readonly scope: "adaptiq";
+    readonly id: "workspace";
+};
+/**
+ * The grant record in `$DSH_HOME/.credentials.yaml` (0600, cross-process
+ * writer lock), plus the optional API-key reference for headless use.
+ * @param ctx - the plugin context with `credentials`.
+ * @param apiKeyEnv - credential reference name of the API key.
+ * @returns the credential store.
+ */
+export declare function harnessCredentialStore(ctx: Context, apiKeyEnv: string): CredentialStore;
+/**
+ * Preferences and per-conversation memory choices in one JSON file.
+ * @param path - file path under the harness home.
+ * @returns the state store.
+ */
+export declare function fileStateStore(path: string): StateStore;
+/**
+ * Open a URL in the default browser of the computer the harness runs on.
+ * @param url - an http(s) URL.
+ * @returns whether a browser process was started.
+ */
+export declare function openInBrowser(url: string): Promise<boolean>;

package/lib/types/host/stream.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Chat Completions SSE → harness stream chunks. Follows the adapter protocol:
+ * block indexes in first-seen order, raw JSON tool arguments, usage before
+ * finish, nothing after finish.
+ */
+import type { StreamChunk, TokenUsage } from '@deepseek-ai/dsh-llm';
+import { type SseEvent } from '@adaptiqai/core';
+export { mapUsage, parseSse, type SseEvent } from '@adaptiqai/core';
+/** Hooks the translator calls as the stream unfolds. */
+export interface TranslateHooks {
+    /** A server progress frame (`adaptiq.progress`): stage such as `context.preparing` or `inference.queued`. */
+    onProgress?(stage: string, elapsedMs: number | null): void;
+    /** The first visible output (text, thinking or a tool call) arrived. */
+    onFirstOutput?(): void;
+    /** An in-band error: map it to the thrown failure. */
+    onError(payload: Record<string, unknown>): Error;
+    onUsage?(usage: TokenUsage): void;
+}
+/**
+ * Translate decoded SSE events into harness stream chunks.
+ * @param events - parsed SSE events.
+ * @param hooks - progress, usage and error mapping.
+ * @returns stream chunks ending in exactly one finish chunk.
+ */
+export declare function translate(events: AsyncIterable<SseEvent>, hooks: TranslateHooks): AsyncGenerator<StreamChunk>;

package/lib/types/host/tools.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Workspace } from '@adaptiqai/core';
+/**
+ * The media type for a file name.
+ * @param name - file name.
+ * @returns a media type, `text/plain` for source code.
+ */
+export declare function mediaTypeOf(name: string): string;
+/**
+ * Register the AdaptiqAI agent tools.
+ * @param ctx - context with the `tools` service.
+ * @param workspace - the workspace.
+ */
+export declare function registerTools(ctx: Context, workspace: Workspace): void;

package/lib/types/host/wire.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Harness request → OpenAI Chat Completions body. Model-specific behaviour
+ * (thinking field and values, sampling defaults) comes only from the
+ * model's catalog entry.
+ */
+import type { GenerateOptions } from '@deepseek-ai/dsh-llm';
+import { type CatalogModel } from '@adaptiqai/core';
+/** One Chat Completions message. */
+export type WireMessage = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: string;
+} | {
+    role: 'assistant';
+    content: string | null;
+    tool_calls?: WireToolCall[];
+    [reasoning: string]: unknown;
+} | {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+};
+export interface WireToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** Per-request facts the adapter adds beyond the harness request. */
+export interface WireExtras {
+    /** False when the person chose not to save new messages of this conversation. */
+    readonly remember: boolean;
+    /** True when the server already stores this conversation. */
+    readonly stored?: boolean;
+    /** Ask for streamed usage (always on for the adapter). */
+    readonly includeUsage?: boolean;
+}
+/**
+ * Convert the harness history to Chat Completions messages.
+ * @param options - the harness request.
+ * @returns the wire messages in order.
+ */
+export declare function wireMessages(options: Pick<GenerateOptions, 'messages' | 'system'>): WireMessage[];
+/**
+ * Build the request body for one call.
+ * @param options - the harness request.
+ * @param model - the model's catalog entry, when known.
+ * @param extras - memory preference and stream options.
+ * @returns the JSON body.
+ */
+export declare function buildChatBody(options: GenerateOptions, model: CatalogModel | null, extras: WireExtras): Record<string, unknown>;
+/**
+ * The session headers for one call. A title request carries none: it reuses the
+ * conversation id with a different history and must not fork the saved conversation.
+ * @param options - the harness request.
+ * @returns header name → value.
+ */
+export declare function sessionHeaders(options: Pick<GenerateOptions, 'sessionId' | 'purpose'>): Record<string, string>;

package/locale/da.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "AdaptiqAI",
+    "description": "AdaptiqAI-modeller med indbygget hukommelse op til 5M tokens og din Knowledge. Opret konto, få en model og arbejd uden at forlade harnessen"
+  }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "AdaptiqAI",
+    "description": "AdaptiqAI models with native memory up to 5M tokens and your Knowledge. Sign up, get a model and work without leaving the harness"
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "AdaptiqAI",
+    "description": "AdaptiqAI 模型，原生记忆最高 500 万 tokens，并可使用你的知识库。无需离开 Harness 即可注册、获取模型并开始工作"
+  }
+}