@andorra-labs/code 0.0.0-stage → 0.1.5

package/dist/vendor/engine/runtime/ai/api/openai-responses.d.ts

@@ -0,0 +1,13 @@
+import type { ResponseCreateParamsStreaming } from "openai/resources/responses/responses.js";
+import type { SimpleStreamOptions, StreamFunction, StreamOptions } from "../types.js";
+export interface OpenAIResponsesOptions extends StreamOptions {
+    reasoningEffort?: "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+    reasoningSummary?: "auto" | "detailed" | "concise" | null;
+    serviceTier?: ResponseCreateParamsStreaming["service_tier"];
+    toolChoice?: ResponseCreateParamsStreaming["tool_choice"];
+}
+/**
+ * Generate function for OpenAI Responses API
+ */
+export declare const andorraStream: StreamFunction<"openai-responses", OpenAIResponsesOptions>;
+export declare const andorraStreamSimple: StreamFunction<"openai-responses", SimpleStreamOptions>;

package/dist/vendor/engine/runtime/ai/api/openai-responses.js

@@ -0,0 +1,292 @@
+import OpenAI from "openai";
+import { andorraClampThinkingLevel } from "../models.js";
+import { andorraFormatProviderError, andorraNormalizeProviderError } from "../utils/error-body.js";
+import { AndorraAssistantMessageEventStream } from "../utils/event-stream.js";
+import { andorraHeadersToRecord } from "../utils/headers.js";
+import { andorraGetAndorraUserAgent } from "../utils/pi-user-agent.js";
+import { andorraGetProviderEnvValue } from "../utils/provider-env.js";
+import { andorraRetryProviderRequest } from "../utils/provider-retry.js";
+import { andorraGetDeclaredTools, andorraResolveTranscript, andorraResolveTranscriptTools } from "../utils/transcript.js";
+import { andorraCreateGrammarToolInputProperties } from "./constrained-sampling.js";
+import { andorraBuildCopilotDynamicHeaders, andorraHasCopilotVisionInput } from "./github-copilot-headers.js";
+import { andorraClampOpenAIPromptCacheKey } from "./openai-prompt-cache.js";
+import { andorraConvertResponsesMessages, andorraConvertResponsesTools, andorraProcessResponsesStream } from "./openai-responses-shared.js";
+import { andorraBuildBaseOptions } from "./simple-options.js";
+const OPENAI_TOOL_CALL_PROVIDERS = new Set(["openai", "openai-codex", "opencode"]);
+// OpenAI Responses rejects max_output_tokens below 16: https://github.com/earendil-works/pi/issues/6265
+const OPENAI_RESPONSES_MIN_OUTPUT_TOKENS = 16;
+function andorraHasHeader(headers, name) {
+    if (!headers)
+        return false;
+    const expected = name.toLowerCase();
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === expected && value !== null && value.trim().length > 0)
+            return true;
+    }
+    return false;
+}
+function andorraGetClientApiKey(provider, apiKey, headers) {
+    if (apiKey)
+        return apiKey;
+    if (andorraHasHeader(headers, "authorization") || andorraHasHeader(headers, "cf-aig-authorization"))
+        return "unused";
+    throw new Error(`No API key for provider: ${provider}`);
+}
+function andorraDetectSessionAffinityFormat(model) {
+    return model.provider === "openrouter" || model.baseUrl.includes("openrouter.ai") ? "openrouter" : "openai";
+}
+/**
+ * Resolve cache retention preference.
+ * Defaults to "short" and uses ANDORRA_ENGINE_CACHE_RETENTION for backward compatibility.
+ */
+function andorraResolveCacheRetention(cacheRetention, env) {
+    if (cacheRetention) {
+        return cacheRetention;
+    }
+    if (andorraGetProviderEnvValue("ANDORRA_ENGINE_CACHE_RETENTION", env) === "long") {
+        return "long";
+    }
+    return "short";
+}
+function andorraGetCompat(model) {
+    return {
+        supportsDeveloperRole: model.compat?.supportsDeveloperRole ?? true,
+        supportsMidConvoSystemMessages: model.compat?.supportsMidConvoSystemMessages ?? false,
+        sessionAffinityFormat: model.compat?.sessionAffinityFormat ?? andorraDetectSessionAffinityFormat(model),
+        supportsLongCacheRetention: model.compat?.supportsLongCacheRetention ?? true,
+        supportsStrictMode: model.compat?.supportsStrictMode ?? false,
+        supportsOpenAIGrammarTools: model.compat?.supportsOpenAIGrammarTools ?? false,
+        supportsAdditionalTools: model.compat?.supportsAdditionalTools ?? false,
+        supportsToolSearch: model.compat?.supportsToolSearch ?? false,
+        supportsExplicitPromptCacheMode: model.compat?.supportsExplicitPromptCacheMode ?? false,
+        supportsMaxOutputTokens: model.compat?.supportsMaxOutputTokens ?? true,
+    };
+}
+function andorraGetPromptCacheRetention(compat, cacheRetention) {
+    return cacheRetention === "long" && compat.supportsLongCacheRetention && !compat.supportsExplicitPromptCacheMode
+        ? "24h"
+        : undefined;
+}
+function andorraGetPromptCacheOptions(compat, cacheRetention) {
+    if (!compat.supportsExplicitPromptCacheMode)
+        return undefined;
+    if (cacheRetention === "none")
+        return { mode: "explicit" };
+    if (cacheRetention === "long" && compat.supportsLongCacheRetention)
+        return { ttl: "30m" };
+    return undefined;
+}
+/**
+ * Generate function for OpenAI Responses API
+ */
+export const andorraStream = (model, context, options) => {
+    const stream = new AndorraAssistantMessageEventStream();
+    const normalizedContext = andorraResolveTranscript(context, andorraGetCompat(model).supportsMidConvoSystemMessages);
+    // Start async processing
+    (async () => {
+        const output = {
+            role: "assistant",
+            content: [],
+            api: model.api,
+            provider: model.provider,
+            model: model.id,
+            usage: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                totalTokens: 0,
+                cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+            },
+            stopReason: "pending",
+            timestamp: Date.now(),
+        };
+        try {
+            // Create OpenAI client
+            const apiKey = andorraGetClientApiKey(model.provider, options?.apiKey, options?.headers);
+            const cacheRetention = andorraResolveCacheRetention(options?.cacheRetention, options?.env);
+            const cacheSessionId = cacheRetention === "none" ? undefined : options?.sessionId;
+            const compat = andorraGetCompat(model);
+            const grammarToolInputProperties = andorraCreateGrammarToolInputProperties(andorraGetDeclaredTools(normalizedContext.messages), compat.supportsOpenAIGrammarTools);
+            const client = andorraCreateClient(model, normalizedContext, apiKey, options?.headers, options?.fetch, cacheSessionId);
+            let params = andorraBuildParams(model, normalizedContext, options, compat, grammarToolInputProperties);
+            const nextParams = await options?.onPayload?.(params, model);
+            if (nextParams !== undefined) {
+                params = nextParams;
+            }
+            const requestOptions = {
+                ...(options?.signal ? { signal: options.signal } : {}),
+                ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+                maxRetries: 0,
+            };
+            const { data: openaiStream, response } = await andorraRetryProviderRequest(() => client.responses.create(params, requestOptions).withResponse(), {
+                maxRetries: options?.maxRetries,
+                maxRetryDelayMs: options?.maxRetryDelayMs,
+                signal: options?.signal,
+            });
+            await options?.onResponse?.({ status: response.status, headers: andorraHeadersToRecord(response.headers) }, model);
+            stream.push({ type: "start", partial: output });
+            await andorraProcessResponsesStream(openaiStream, output, stream, model, {
+                serviceTier: options?.serviceTier,
+                grammarToolInputProperties,
+                applyServiceTierPricing: (usage, serviceTier) => andorraApplyServiceTierPricing(usage, serviceTier, model),
+            });
+            if (options?.signal?.aborted) {
+                throw new Error("Request was aborted");
+            }
+            if (output.stopReason === "pending") {
+                throw new Error("OpenAI Responses stream ended without a stop reason");
+            }
+            if (output.stopReason === "aborted" || output.stopReason === "error") {
+                throw new Error(output.errorMessage || "An unknown error occurred");
+            }
+            stream.push({ type: "done", reason: output.stopReason, message: output });
+            stream.end();
+        }
+        catch (error) {
+            for (const block of output.content) {
+                delete block.index;
+                // Streaming scratch buffers are only used during parsing; never persist them.
+                delete block.partialJson;
+                delete block.customInput;
+            }
+            output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+            output.errorMessage = andorraFormatProviderError(andorraNormalizeProviderError(error), `${model.provider === "openai" ? "OpenAI" : model.provider} API error`);
+            stream.push({ type: "error", reason: output.stopReason, error: output });
+            stream.end();
+        }
+    })();
+    return stream;
+};
+export const andorraStreamSimple = (model, context, options) => {
+    andorraGetClientApiKey(model.provider, options?.apiKey, options?.headers);
+    const base = {
+        ...andorraBuildBaseOptions(model, context, options, options?.apiKey),
+        toolChoice: options?.toolChoice,
+    };
+    const clampedReasoning = options?.reasoning ? andorraClampThinkingLevel(model, options.reasoning) : undefined;
+    const reasoningEffort = clampedReasoning === "off" ? undefined : clampedReasoning;
+    return andorraStream(model, context, {
+        ...base,
+        reasoningEffort,
+    });
+};
+function andorraCreateClient(model, context, apiKey, optionsHeaders, fetch, sessionId) {
+    const compat = andorraGetCompat(model);
+    const headers = { "User-Agent": andorraGetAndorraUserAgent(), ...model.headers };
+    if (model.provider === "github-copilot") {
+        const hasImages = andorraHasCopilotVisionInput(context.messages);
+        const copilotHeaders = andorraBuildCopilotDynamicHeaders({
+            messages: context.messages,
+            hasImages,
+        });
+        Object.assign(headers, copilotHeaders);
+    }
+    if (sessionId) {
+        if (compat.sessionAffinityFormat === "openrouter") {
+            headers["x-session-id"] = sessionId;
+        }
+        else {
+            if (compat.sessionAffinityFormat === "openai") {
+                headers.session_id = sessionId;
+            }
+            headers["x-client-request-id"] = sessionId;
+        }
+    }
+    // Merge options headers last so they can override defaults
+    if (optionsHeaders) {
+        Object.assign(headers, optionsHeaders);
+    }
+    return new OpenAI({
+        apiKey,
+        baseURL: model.baseUrl,
+        dangerouslyAllowBrowser: true,
+        fetch,
+        defaultHeaders: headers,
+    });
+}
+function andorraBuildParams(model, context, options, compat = andorraGetCompat(model), grammarToolInputProperties = andorraCreateGrammarToolInputProperties(andorraGetDeclaredTools(context.messages), compat.supportsOpenAIGrammarTools)) {
+    const transcriptTools = andorraResolveTranscriptTools(context.messages, compat.supportsAdditionalTools || compat.supportsToolSearch);
+    const messages = andorraConvertResponsesMessages(model, context, OPENAI_TOOL_CALL_PROVIDERS, {
+        grammarToolInputProperties,
+        supportsMidConvoSystemMessages: compat.supportsMidConvoSystemMessages,
+        supportsAdditionalTools: compat.supportsAdditionalTools,
+        supportsToolSearch: compat.supportsToolSearch,
+        toolOptions: {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        },
+    });
+    const cacheRetention = andorraResolveCacheRetention(options?.cacheRetention, options?.env);
+    const params = {
+        model: model.id,
+        input: messages,
+        stream: true,
+        prompt_cache_key: cacheRetention === "none" ? undefined : andorraClampOpenAIPromptCacheKey(options?.sessionId),
+        prompt_cache_retention: andorraGetPromptCacheRetention(compat, cacheRetention),
+        prompt_cache_options: andorraGetPromptCacheOptions(compat, cacheRetention),
+        store: false,
+    };
+    if (options?.maxTokens && compat.supportsMaxOutputTokens) {
+        params.max_output_tokens = Math.max(options.maxTokens, OPENAI_RESPONSES_MIN_OUTPUT_TOKENS);
+    }
+    if (options?.temperature !== undefined) {
+        params.temperature = options?.temperature;
+    }
+    if (options?.serviceTier !== undefined) {
+        params.service_tier = options.serviceTier;
+    }
+    if (transcriptTools.requestTools.length > 0) {
+        params.tools = andorraConvertResponsesTools(transcriptTools.requestTools, {
+            supportsStrictMode: compat.supportsStrictMode,
+            supportsOpenAIGrammarTools: compat.supportsOpenAIGrammarTools,
+        });
+    }
+    if (options?.toolChoice !== undefined) {
+        params.tool_choice = options.toolChoice;
+    }
+    if (model.reasoning) {
+        if (options?.reasoningEffort || options?.reasoningSummary) {
+            const effort = options?.reasoningEffort
+                ? (model.thinkingLevelMap?.[options.reasoningEffort] ?? options.reasoningEffort)
+                : "medium";
+            params.reasoning = {
+                effort: effort,
+                summary: options?.reasoningSummary || "auto",
+            };
+            params.include = ["reasoning.encrypted_content"];
+        }
+        else if (model.provider !== "github-copilot" && model.thinkingLevelMap?.off !== null) {
+            params.reasoning = {
+                effort: (model.thinkingLevelMap?.off ?? "none"),
+            };
+        }
+        if (model.provider === "xai")
+            params.include = ["reasoning.encrypted_content"];
+    }
+    // Last so custom keys override the named request fields.
+    if (options?.samplingParams) {
+        Object.assign(params, options.samplingParams);
+    }
+    return params;
+}
+function andorraGetServiceTierCostMultiplier(model, serviceTier) {
+    switch (serviceTier) {
+        case "flex":
+            return 0.5;
+        case "priority":
+            return model.id === "gpt-5.5" ? 2.5 : 2;
+        default:
+            return 1;
+    }
+}
+function andorraApplyServiceTierPricing(usage, serviceTier, model) {
+    const multiplier = andorraGetServiceTierCostMultiplier(model, serviceTier);
+    if (multiplier === 1)
+        return;
+    usage.cost.input *= multiplier;
+    usage.cost.output *= multiplier;
+    usage.cost.cacheRead *= multiplier;
+    usage.cost.cacheWrite *= multiplier;
+    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+}

package/dist/vendor/engine/runtime/ai/api/openai-responses.lazy.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderStreams } from "../types.js";
+export declare const andorraOpenAIResponsesApi: () => ProviderStreams;

package/dist/vendor/engine/runtime/ai/api/openai-responses.lazy.js

@@ -0,0 +1,2 @@
+import { andorraLazyApi } from "./lazy.js";
+export const andorraOpenAIResponsesApi = () => andorraLazyApi(() => import("./openai-responses.js"));

package/dist/vendor/engine/runtime/ai/api/openrouter-images.d.ts

@@ -0,0 +1,2 @@
+import type { ImagesFunction, ImagesOptions } from "../types.js";
+export declare const andorraGenerateImages: ImagesFunction<"openrouter-images", ImagesOptions>;

package/dist/vendor/engine/runtime/ai/api/openrouter-images.js

@@ -0,0 +1,131 @@
+import OpenAI from "openai";
+import { andorraFormatProviderError, andorraNormalizeProviderError } from "../utils/error-body.js";
+import { andorraHeadersToRecord, andorraProviderHeadersToRecord } from "../utils/headers.js";
+import { andorraRetryProviderRequest } from "../utils/provider-retry.js";
+import { andorraSanitizeSurrogates } from "../utils/sanitize-unicode.js";
+export const andorraGenerateImages = async (model, context, options) => {
+    const output = {
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        output: [],
+        stopReason: "stop",
+        timestamp: Date.now(),
+    };
+    try {
+        const apiKey = options?.apiKey;
+        if (!apiKey) {
+            throw new Error(`No API key for provider: ${model.provider}`);
+        }
+        const client = andorraCreateClient(model, apiKey, options?.headers, options?.fetch);
+        let params = andorraBuildParams(model, context);
+        const nextParams = await options?.onPayload?.(params, model);
+        if (nextParams !== undefined) {
+            params = nextParams;
+        }
+        const requestOptions = {
+            ...(options?.signal ? { signal: options.signal } : {}),
+            ...(options?.timeoutMs !== undefined ? { timeout: options.timeoutMs } : {}),
+            maxRetries: 0,
+        };
+        const { data: response, response: rawResponse } = await andorraRetryProviderRequest(() => client.chat.completions
+            .create(params, requestOptions)
+            .withResponse(), {
+            maxRetries: options?.maxRetries,
+            maxRetryDelayMs: options?.maxRetryDelayMs,
+            signal: options?.signal,
+        });
+        await options?.onResponse?.({ status: rawResponse.status, headers: andorraHeadersToRecord(rawResponse.headers) }, model);
+        const imageResponse = response;
+        output.responseId = imageResponse.id;
+        if (imageResponse.usage) {
+            output.usage = andorraParseUsage(imageResponse.usage, model);
+        }
+        const choice = imageResponse.choices[0];
+        if (choice) {
+            const content = choice.message.content;
+            if (typeof content === "string" && content.length > 0) {
+                output.output.push({ type: "text", text: content });
+            }
+            for (const image of choice.message.images ?? []) {
+                const imageUrl = typeof image.image_url === "string" ? image.image_url : image.image_url?.url;
+                if (!imageUrl?.startsWith("data:"))
+                    continue;
+                const matches = imageUrl.match(/^data:([^;]+);base64,(.+)$/);
+                if (!matches)
+                    continue;
+                output.output.push({
+                    type: "image",
+                    mimeType: matches[1],
+                    data: matches[2],
+                });
+            }
+        }
+        return output;
+    }
+    catch (error) {
+        output.stopReason = options?.signal?.aborted ? "aborted" : "error";
+        output.errorMessage = andorraFormatProviderError(andorraNormalizeProviderError(error));
+        return output;
+    }
+};
+function andorraCreateClient(model, apiKey, optionsHeaders, fetch) {
+    return new OpenAI({
+        apiKey,
+        baseURL: model.baseUrl,
+        dangerouslyAllowBrowser: true,
+        fetch,
+        defaultHeaders: andorraProviderHeadersToRecord({ ...model.headers, ...optionsHeaders }),
+    });
+}
+function andorraBuildParams(model, context) {
+    const content = context.input.map((item) => {
+        if (item.type === "text") {
+            return {
+                type: "text",
+                text: andorraSanitizeSurrogates(item.text),
+            };
+        }
+        return {
+            type: "image_url",
+            image_url: {
+                url: `data:${item.mimeType};base64,${item.data}`,
+            },
+        };
+    });
+    return {
+        model: model.id,
+        messages: [
+            {
+                role: "user",
+                content,
+            },
+        ],
+        stream: false,
+        modalities: model.output.includes("text") ? ["image", "text"] : ["image"],
+    };
+}
+function andorraParseUsage(rawUsage, model) {
+    const promptTokens = rawUsage.prompt_tokens || 0;
+    const reportedCachedTokens = rawUsage.prompt_tokens_details?.cached_tokens || 0;
+    const cacheWriteTokens = rawUsage.prompt_tokens_details?.cache_write_tokens || 0;
+    const cacheReadTokens = cacheWriteTokens > 0 ? Math.max(0, reportedCachedTokens - cacheWriteTokens) : reportedCachedTokens;
+    const input = Math.max(0, promptTokens - cacheReadTokens - cacheWriteTokens);
+    const output = rawUsage.completion_tokens || 0;
+    const usage = {
+        input,
+        output,
+        cacheRead: cacheReadTokens,
+        cacheWrite: cacheWriteTokens,
+        totalTokens: input + output + cacheReadTokens + cacheWriteTokens,
+        cost: {
+            input: (model.cost.input / 1000000) * input,
+            output: (model.cost.output / 1000000) * output,
+            cacheRead: (model.cost.cacheRead / 1000000) * cacheReadTokens,
+            cacheWrite: (model.cost.cacheWrite / 1000000) * cacheWriteTokens,
+            total: 0,
+        },
+    };
+    usage.cost.total = usage.cost.input + usage.cost.output + usage.cost.cacheRead + usage.cost.cacheWrite;
+    return usage;
+}

package/dist/vendor/engine/runtime/ai/api/openrouter-images.lazy.d.ts

@@ -0,0 +1,2 @@
+import type { ProviderImages } from "../types.js";
+export declare const andorraOpenrouterImagesApi: () => ProviderImages;

package/dist/vendor/engine/runtime/ai/api/openrouter-images.lazy.js

@@ -0,0 +1,3 @@
+export const andorraOpenrouterImagesApi = () => ({
+    generateImages: async (model, context, options) => (await import("./openrouter-images.js")).andorraGenerateImages(model, context, options),
+});

package/dist/vendor/engine/runtime/ai/api/pi-messages.d.ts

@@ -0,0 +1,98 @@
+/**
+ * pi-messages API implementation.
+ *
+ * Streams pi's own message protocol directly to a backend: the request is a
+ * single POST of `{ model, context, options }` to `<baseUrl>/messages`, the
+ * response is an SSE stream of serialized assistant-message events plus a
+ * terminal `done`/`error` event. This is the wire protocol spoken by the
+ * Radius gateway, but any backend implementing it can be used, e.g. via a
+ * models.json custom provider with `"api": "pi-messages"`.
+ */
+import type { AssistantMessage, JsonObject, SimpleStreamOptions, StreamFunction, StreamOptions, ThinkingLevel, ToolCall } from "../types.js";
+export interface AndorraMessagesOptions extends StreamOptions {
+    reasoning?: ThinkingLevel;
+    toolChoice?: "auto" | "none" | "required" | {
+        type: "function";
+        function: {
+            name: string;
+        };
+    };
+    /** Ask the backend for debug metadata (e.g. routing response headers). */
+    debug?: boolean;
+}
+type AndorraMessagesUsage = AssistantMessage["usage"];
+type AndorraMessagesStopReason = AssistantMessage["stopReason"];
+/** Impact summary of a server-side message rewrite (e.g. a gateway policy). */
+export type AndorraMessagesRewriteImpact = {
+    policyId: string;
+    policyVersion: number;
+    changed: boolean;
+    tokenCountChange: number;
+    messageCountChange: number;
+    systemPromptChanged: boolean;
+};
+/** Serialized assistant-message event as sent by a pi-messages backend. */
+export type AndorraMessagesEvent = {
+    type: "start";
+} | {
+    type: "text_start";
+    contentIndex: number;
+} | {
+    type: "text_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    type: "text_end";
+    contentIndex: number;
+    content: string;
+    contentSignature?: string;
+} | {
+    type: "thinking_start";
+    contentIndex: number;
+} | {
+    type: "thinking_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    type: "thinking_end";
+    contentIndex: number;
+    content: string;
+    contentSignature?: string;
+    redacted?: boolean;
+} | {
+    type: "toolcall_start";
+    contentIndex: number;
+    id: string;
+    toolName: string;
+} | {
+    type: "toolcall_delta";
+    contentIndex: number;
+    delta: string;
+} | {
+    type: "toolcall_end";
+    contentIndex: number;
+    toolCall: ToolCall;
+} | {
+    type: "done";
+    reason: Extract<AndorraMessagesStopReason, "stop" | "length" | "toolUse">;
+    usage: AndorraMessagesUsage;
+    responseId?: string;
+    providerThinkingLevel?: string;
+    rewrite?: AndorraMessagesRewriteImpact;
+} | {
+    type: "error";
+    reason: Extract<AndorraMessagesStopReason, "aborted" | "error">;
+    usage: AndorraMessagesUsage;
+    errorMessage?: string;
+    responseId?: string;
+    providerThinkingLevel?: string;
+    rewrite?: AndorraMessagesRewriteImpact;
+};
+export declare class AndorraMessagesResponseError extends Error {
+    code?: string;
+    readonly diagnosticDetails: JsonObject;
+    constructor(message: string, code: string | undefined, diagnosticDetails: JsonObject);
+}
+export declare const andorraStream: StreamFunction<"pi-messages", AndorraMessagesOptions>;
+export declare const andorraStreamSimple: StreamFunction<"pi-messages", SimpleStreamOptions>;
+export {};