@fungi.computer/parakeet 0.0.0-stage → 0.0.1

package/dist/index.js

@@ -0,0 +1,4 @@
+export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
+export { Parakeet, ParakeetView } from "./parakeet.js";
+export { InteractionPanel, } from "./components/InteractionPanel.js";
+export * from "./agent-head.js";

package/dist/lib/failure.d.ts

@@ -0,0 +1,2 @@
+/** Report an operation failure without exposing Session or tool contents. */
+export declare function reportFailure(operation: string, cause: unknown): void;

package/dist/lib/failure.js

@@ -0,0 +1,9 @@
+import * as Redacted from "effect/Redacted";
+/** Report an operation failure without exposing Session or tool contents. */
+export function reportFailure(operation, cause) {
+    console.error(JSON.stringify({
+        event: "parakeet_operation_failed",
+        operation,
+        causeKind: cause instanceof Error ? "error" : "non_error",
+    }), Redacted.make(cause));
+}

package/dist/markdown.d.ts

@@ -0,0 +1,3 @@
+export type { BlockNode as MarkdownBlock, InlineNode as MarkdownInline, } from "@tanstack/markdown";
+/** Parse chat Markdown for headless hosts, including terminal presentation. */
+export declare function useMarkdown(content: string): import("@tanstack/markdown").MarkdownDocument;

package/dist/markdown.js

@@ -0,0 +1,6 @@
+import { parseMarkdown } from "@tanstack/markdown/parser";
+import { useMemo } from "react";
+/** Parse chat Markdown for headless hosts, including terminal presentation. */
+export function useMarkdown(content) {
+    return useMemo(() => parseMarkdown(content, { allowHtml: false, frontmatter: false }), [content]);
+}

package/dist/model-commands.d.ts

@@ -0,0 +1,44 @@
+import { type ModelPreference } from "@fungi.computer/shiitake/model-preference";
+import { type WhistleAvailability, type WhistleRuntime, type WhistleContribution } from "@fungi.computer/whistle";
+import { type ModelAccountContext } from "./account-commands.js";
+/** A host's maintained catalog projection; no credentials or provider execution. */
+export type SessionModelChoice = Readonly<{
+    /** Stable provider identity used in a Session preference. */
+    providerId: string;
+    /** Provider label displayed by clients. */
+    providerName: string;
+    /** Model identity within this provider. */
+    id: string;
+    /** Human-facing model label. */
+    name: string;
+    /** Thinking levels supported by this catalog entry. */
+    reasoning: readonly NonNullable<ModelPreference["reasoning"]>[];
+}>;
+export type ModelPreferenceOwner = Readonly<{
+    modelPreference: Readonly<{
+        read: () => Promise<ModelPreference | null>;
+        set: (preference: ModelPreference | null) => Promise<void>;
+    }>;
+}>;
+/** Contribution identity, catalog and optional local model-picker presentation. */
+export type SessionModelCommandOptions = Readonly<{
+    /** Shared credential owner and policy for the interactive provider flow. */
+    account: ModelAccountContext;
+    /** Host source that owns the contribution lease. */
+    sourceId: string;
+    /** Namespace for the semantic model command. */
+    namespace: string;
+    /** Catalog used to describe and validate explicit selections. */
+    models: readonly SessionModelChoice[];
+    /** Read the live catalog after interactive provider sign-in. */
+    refreshModels: (signal: AbortSignal) => Promise<readonly SessionModelChoice[]>;
+    /** Current semantic availability, checked again before dispatch. */
+    availability?: () => WhistleAvailability;
+}>;
+/** Describe and invoke the ordinary model-preference owner from any client. */
+export declare function sessionModelCommandDefinitions(session: ModelPreferenceOwner, options: SessionModelCommandOptions): WhistleContribution["commands"];
+/** Contribute one model action; owners may update its definitions through the lease. */
+export declare function contributeModelCommands(commands: Pick<WhistleRuntime, "contribute">, session: ModelPreferenceOwner, options: SessionModelCommandOptions): Readonly<{
+    update: (commands: WhistleContribution["commands"]) => void;
+    dispose: () => void;
+}>;

package/dist/model-commands.js

@@ -0,0 +1,232 @@
+import { modelPreferenceJsonSchema, parseModelPreference, } from "@fungi.computer/shiitake/model-preference";
+import { WhistleActionError, } from "@fungi.computer/whistle";
+import { z } from "zod";
+import { loginRegistry, signInProvider, } from "./account-commands.js";
+import { providerChoices } from "./provider-choices.js";
+const defaultChoice = "default";
+function modelLabel(model) {
+    return `${model.providerName} · ${model.name}`;
+}
+/** Current model first, then providers and models by name; no provider is favoured. */
+function orderModels(models, current) {
+    return [...models].sort((left, right) => {
+        const leftCurrent = left.id === current?.modelId && left.providerId === current.providerId;
+        const rightCurrent = right.id === current?.modelId && right.providerId === current.providerId;
+        if (leftCurrent !== rightCurrent)
+            return leftCurrent ? -1 : 1;
+        return (left.providerName.localeCompare(right.providerName) ||
+            left.name.localeCompare(right.name));
+    });
+}
+async function chooseReasoning(interaction, model, current) {
+    if (model.reasoning.length === 0)
+        return undefined;
+    const answer = await interaction.prompt({
+        type: "choice",
+        message: `Thinking level for ${model.name}`,
+        options: [
+            { value: defaultChoice, label: "Model default" },
+            ...model.reasoning.map((level) => ({
+                value: level,
+                label: level === current ? `${level} (current)` : level,
+            })),
+        ],
+    });
+    return model.reasoning.find((level) => level === answer);
+}
+/** Leave one Whistle option for inheriting the Agent model. */
+const maximumModelOptions = 255;
+async function chooseProviderModels(interaction, models, account, refreshModels) {
+    const { owner } = account;
+    const [access, registry] = await Promise.all([
+        owner.access(interaction.signal),
+        owner
+            .providers(interaction.signal)
+            .then((providers) => loginRegistry(providers, account)),
+    ]);
+    // The default is discoverable before its authenticated catalog exists.
+    const providers = registry.filter((provider) => provider.id === "fungi");
+    for (const model of new Map(models.map((model) => [model.providerId, model])).values()) {
+        const provider = registry.find((candidate) => candidate.id === model.providerId);
+        if (providers.some((candidate) => candidate.id === model.providerId))
+            continue;
+        if (provider)
+            providers.push(provider);
+        else if (access.some((candidate) => candidate.providerId === model.providerId &&
+            account.policy.loginAllowed({
+                providerId: candidate.providerId,
+                method: candidate.type === "oauth" ? "subscription" : "api_key",
+                host: account.host,
+                scope: account.scope,
+            })))
+            providers.push({
+                id: model.providerId,
+                name: model.providerName,
+                methods: [],
+            });
+    }
+    const providerId = await interaction.prompt({
+        type: "choice",
+        message: "Model",
+        collapsedGroup: "More providers",
+        options: [
+            { value: defaultChoice, label: "Use agent model" },
+            ...providerChoices(providers, access, owner.popularProviderIds, "model").slice(0, maximumModelOptions),
+        ],
+    });
+    if (providerId === defaultChoice)
+        return null;
+    const provider = providers.find((candidate) => candidate.id === providerId);
+    if (!provider)
+        throw new WhistleActionError("provider_unavailable", "Choose a listed provider.");
+    let catalog = models;
+    if (!access.some((candidate) => candidate.providerId === providerId)) {
+        await signInProvider(owner, provider, interaction);
+        catalog = await refreshModels(interaction.signal);
+    }
+    const selectedModels = catalog
+        .filter((model) => model.providerId === providerId)
+        .slice(0, maximumModelOptions);
+    if (selectedModels.length === 0)
+        throw new WhistleActionError("model_unavailable", `${provider.name} has no available models. Retry /model.`);
+    return selectedModels;
+}
+/** Describe and invoke the ordinary model-preference owner from any client. */
+export function sessionModelCommandDefinitions(session, options) {
+    const preferenceSchema = z
+        .record(z.string(), z.json())
+        .parse(modelPreferenceJsonSchema);
+    const knownChoices = options.models.map((model) => ({
+        title: `${model.providerName} · ${model.name}`,
+        properties: {
+            providerId: { const: model.providerId },
+            modelId: { const: model.id },
+            reasoning: model.reasoning.length === 0 ? false : { enum: [...model.reasoning] },
+        },
+    }));
+    const selectionSchema = knownChoices.length === 0
+        ? { not: {} }
+        : { allOf: [preferenceSchema, { oneOf: knownChoices }] };
+    return [
+        {
+            id: "model",
+            title: "Model",
+            category: "Settings",
+            description: "Choose a model",
+            projections: {
+                agent: {},
+                palette: {},
+                help: {},
+                slash: { aliases: ["model"] },
+            },
+            action: {
+                inputSchema: {
+                    anyOf: [{ type: "null", title: "Use agent model" }, selectionSchema],
+                },
+                outputSchema: { anyOf: [{ type: "null" }, preferenceSchema] },
+            },
+            availability: options.availability ?? (() => ({ status: "available" })),
+            handler: async (input) => {
+                if (input.arguments === undefined) {
+                    const interaction = input.interaction;
+                    if (input.origin === "agent" || interaction === undefined)
+                        return session.modelPreference.read();
+                    const current = await session.modelPreference.read();
+                    const ordered = await chooseProviderModels(interaction, orderModels(options.models, current), options.account, options.refreshModels);
+                    if (ordered === null) {
+                        await session.modelPreference.set(null);
+                        return session.modelPreference.read();
+                    }
+                    const answer = await interaction.prompt({
+                        type: "choice",
+                        message: "Model",
+                        options: [
+                            { value: defaultChoice, label: "Use agent model" },
+                            ...ordered.map((model, index) => ({
+                                value: String(index),
+                                label: model.providerId === current?.providerId &&
+                                    model.id === current.modelId
+                                    ? `${modelLabel(model)} (current)`
+                                    : modelLabel(model),
+                            })),
+                        ],
+                    });
+                    const model = answer === defaultChoice ? undefined : ordered[Number(answer)];
+                    let chosen = null;
+                    if (model !== undefined) {
+                        const reasoning = await chooseReasoning(interaction, model, current?.reasoning);
+                        chosen =
+                            reasoning === undefined
+                                ? { providerId: model.providerId, modelId: model.id }
+                                : {
+                                    providerId: model.providerId,
+                                    modelId: model.id,
+                                    reasoning,
+                                };
+                    }
+                    await session.modelPreference.set(chosen);
+                    // The mounted owner's effective-model label confirms the choice.
+                    // A success notice would keep the choice dialog focused until Esc.
+                    return session.modelPreference.read();
+                }
+                let preference;
+                try {
+                    preference = parseModelPreference(input.arguments);
+                }
+                catch {
+                    throw new WhistleActionError("invalid_model_preference", "Model preference arguments are invalid");
+                }
+                if (preference !== null) {
+                    const selected = preference;
+                    const model = options.models.find((choice) => choice.providerId === selected.providerId &&
+                        choice.id === selected.modelId);
+                    if (model === undefined)
+                        throw new WhistleActionError("model_unavailable", "That model is not in the current catalog");
+                    if (selected.reasoning !== undefined &&
+                        !model.reasoning.includes(selected.reasoning))
+                        throw new WhistleActionError("reasoning_unavailable", "That thinking level is not supported by this model");
+                }
+                await session.modelPreference.set(preference);
+                return session.modelPreference.read();
+            },
+        },
+        {
+            id: "thinking",
+            title: "Thinking level",
+            category: "Settings",
+            description: "Choose thinking effort",
+            projections: {
+                palette: { order: 1 },
+                help: {},
+                slash: { aliases: ["thinking"] },
+            },
+            availability: options.availability ?? (() => ({ status: "available" })),
+            handler: async (input) => {
+                const interaction = input.interaction;
+                if (interaction === undefined)
+                    throw new WhistleActionError("interaction_required", "Choosing a thinking level needs a person.");
+                const current = await session.modelPreference.read();
+                const model = options.models.find((choice) => choice.providerId === current?.providerId &&
+                    choice.id === current.modelId);
+                if (current === null || model === undefined)
+                    throw new WhistleActionError("model_required", "Choose a model with /model before its thinking level.");
+                if (model.reasoning.length === 0)
+                    throw new WhistleActionError("reasoning_unavailable", `${model.name} has no thinking levels.`);
+                const reasoning = await chooseReasoning(interaction, model, current.reasoning);
+                const chosen = reasoning === undefined
+                    ? { providerId: model.providerId, modelId: model.id }
+                    : { providerId: model.providerId, modelId: model.id, reasoning };
+                await session.modelPreference.set(chosen);
+                return session.modelPreference.read();
+            },
+        },
+    ];
+}
+/** Contribute one model action; owners may update its definitions through the lease. */
+export function contributeModelCommands(commands, session, options) {
+    return commands.contribute({
+        sourceId: options.sourceId,
+        namespace: options.namespace,
+        commands: sessionModelCommandDefinitions(session, options),
+    });
+}

package/dist/parakeet.d.ts

@@ -0,0 +1,77 @@
+import type { ClientEntryV1 } from "@fungi.computer/shiitake/client-entry";
+import { type ReactElement, type ReactNode } from "react";
+import { type ParakeetAuthorOf } from "./core/author-labels.js";
+import type { ToolItem } from "./store/types.js";
+import type { ParakeetSession } from "./session.js";
+import type { RowV1 } from "@fungi.computer/gills";
+import { type ParakeetCommandRuntime } from "./commands/use-slash-commands.js";
+/** Public composer options for an anonymous visitor conversation. */
+export type ParakeetVisitor = Readonly<{
+    /** Agent display name used by the visitor's composer. */
+    agentName: string;
+}>;
+/** Props for the standalone retained conversation surface. */
+export type ParakeetProps = Readonly<{
+    /** Show short identity suffixes for same-named authors; never in visitor mode. */
+    disambiguateAuthors?: boolean | undefined;
+    /**
+     * Read the author to show from a message's opaque host metadata. Absent,
+     * lines show no author.
+     */
+    authorOf?: ParakeetAuthorOf | undefined;
+    /** Visitor mode hides internal readouts and disables slash commands. */
+    visitor?: ParakeetVisitor | undefined;
+    /** Visitor conversations render Markdown without loading images or unsafe links. */
+    markdownPolicy?: "session" | "visitor";
+    /** The typed Session client observed by the conversation surface. */
+    session: ParakeetSession;
+    /** Client entries selected by the host's composition root. */
+    clients?: readonly ClientEntryV1[] | undefined;
+    /** Optional Caps action style for a host-specific quieter composer. */
+    composerActionVariant?: "primary" | "outline" | undefined;
+    /** Optional caller-owned actions for a completed tool result. */
+    renderToolActions?: ((item: ToolItem) => ReactNode) | undefined;
+    /** Optional caller-owned attachment below a settled assistant reply. */
+    renderAssistantAttachment?: ((text: string) => ReactNode) | undefined;
+    /** Optional display text; attachments still receive the original reply. */
+    formatAssistantText?: ((text: string) => string) | undefined;
+    /** Host navigation for transcript links; true prevents browser navigation. */
+    onLink?: ((href: string) => boolean) | undefined;
+    /** Authorize and open a typed target through the host's navigation owner. */
+    onOpen?: ((target: NonNullable<RowV1["open"]>) => void) | undefined;
+    /** Optional caller-owned empty conversation state. */
+    empty?: ReactNode | undefined;
+    /** Optional host Whistle runtime; Parakeet makes its own when omitted. */
+    commands?: ParakeetCommandRuntime | undefined;
+}>;
+/** Props for the reusable retained conversation view. */
+export type ParakeetViewProps = Readonly<{
+    /** Show short identity suffixes for same-named authors; never in visitor mode. */
+    disambiguateAuthors?: boolean | undefined;
+    /** Visitor mode hides internal readouts and disables slash commands. */
+    visitor?: ParakeetVisitor | undefined;
+    /** Optional Caps action style for a host-specific quieter composer. */
+    composerActionVariant?: "primary" | "outline" | undefined;
+    /** Optional caller-owned actions for a completed tool result. */
+    renderToolActions?: ((item: ToolItem) => ReactNode) | undefined;
+    /** Optional caller-owned attachment below a settled assistant reply. */
+    renderAssistantAttachment?: ((text: string) => ReactNode) | undefined;
+    /** Optional display text; attachments still receive the original reply. */
+    formatAssistantText?: ((text: string) => string) | undefined;
+    /** Host navigation for transcript links; true prevents browser navigation. */
+    onLink?: ((href: string) => boolean) | undefined;
+    /** Authorize and open a typed target through the host's navigation owner. */
+    onOpen?: ((target: NonNullable<RowV1["open"]>) => void) | undefined;
+    /** Optional caller-owned empty conversation state. */
+    empty?: ReactNode | undefined;
+    /**
+     * Optional host Whistle runtime holding the host's own commands. Parakeet
+     * adds its built-ins and the Session's advertised commands to it, and makes
+     * a private runtime when this is omitted.
+     */
+    commands?: ParakeetCommandRuntime | undefined;
+}>;
+/** Render the retained conversation surface within one Parakeet provider. */
+export declare function ParakeetView({ disambiguateAuthors, visitor, composerActionVariant, empty, commands, renderToolActions, renderAssistantAttachment, formatAssistantText, onLink, onOpen, }: ParakeetViewProps): ReactElement;
+/** Standalone typed composer and exact-message timeline. */
+export declare function Parakeet({ authorOf, disambiguateAuthors, visitor, markdownPolicy, composerActionVariant, empty, session, clients, renderToolActions, renderAssistantAttachment, formatAssistantText, commands, onLink, onOpen, }: ParakeetProps): ReactElement;