@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-fungi-auth-error.d.ts

@@ -0,0 +1,5 @@
+/** Shared refusal for Fungi login refresh, model calls and MCP connections. */
+export declare class FungiSignInRequiredError extends Error {
+    readonly name = "FungiSignInRequiredError";
+    constructor(options?: ErrorOptions);
+}

package/dist/private-fungi-auth-error.js

@@ -0,0 +1,7 @@
+/** Shared refusal for Fungi login refresh, model calls and MCP connections. */
+export class FungiSignInRequiredError extends Error {
+    name = "FungiSignInRequiredError";
+    constructor(options) {
+        super("Sign in to Fungi again to use models and Computers", options);
+    }
+}

package/dist/private-fungi-mcp-connection.d.ts

@@ -0,0 +1,26 @@
+import { type AuthProvider, type FetchLike, type OAuthClientProvider } from "@modelcontextprotocol/client";
+import { type CapabilitySource } from "@fungi.computer/mycelium";
+import { type RequestMcpFormApproval } from "./private-mcp-form-elicitation.js";
+/** The MCP client identity Local reports to the Hub. */
+export declare const fungiMcpClientInfo: Readonly<{
+    name: "fungi-local";
+    version: string;
+}>;
+export declare function rejectedFungiMcpAccess(response: Response): string | undefined;
+export declare function fungiMcpReachableFetch(endpoint: URL, fetchImpl?: FetchLike): FetchLike;
+/** Host-held selection and credentials; neither enters the model's arguments. */
+export type PrivateFungiMcpConnectionOptions = Readonly<{
+    endpoint: URL;
+    authentication?: "oyster-key" | undefined;
+    authProvider: AuthProvider | OAuthClientProvider;
+    /** The maintained transport's fetch seam, also used by the local caller proof. */
+    fetch?: FetchLike;
+    /** Trusted human interaction; never supplied by model arguments. */
+    requestApproval?: RequestMcpFormApproval | undefined;
+}>;
+/**
+ * Add the existing Fungi MCP execute door to a Local run's capability scope.
+ * The remote server selects and authorizes permitted Team Computers per request.
+ * Computer discovery and operations remain inside the maintained execute door.
+ */
+export declare function createPrivateFungiMcpConnection(options: PrivateFungiMcpConnectionOptions): CapabilitySource;

package/dist/private-fungi-mcp-connection.js

@@ -0,0 +1,162 @@
+import { FungiSignInRequiredError } from "./private-fungi-auth-error.js";
+import { createRequire } from "node:module";
+import { Client, StreamableHTTPClientTransport, UnauthorizedError, } from "@modelcontextprotocol/client";
+import { Mycelium } from "@fungi.computer/mycelium";
+import { z } from "zod";
+import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
+import { registerMcpFormElicitation, McpFormApprovalError, } from "./private-mcp-form-elicitation.js";
+const localPackage = z
+    .looseObject({ version: z.string().min(1) })
+    .parse(createRequire(import.meta.url)("../package.json"));
+/** The MCP client identity Local reports to the Hub. */
+export const fungiMcpClientInfo = Object.freeze({
+    name: "fungi-local",
+    version: localPackage.version,
+});
+/**
+ * Fetch rejects (rather than resolving with an HTTP status) only when the Hub
+ * was not reached. Keep TypeError, which the maintained SDK treats as a
+ * network failure, and name the origin the person has to reach.
+ */
+class FungiMcpUnreachableError extends TypeError {
+    constructor(origin, cause) {
+        super(`Can't reach ${origin}${cause instanceof Error ? ` (${cause.message})` : ""}. Check your connection and try again.`, { cause });
+        this.name = "FungiMcpUnreachableError";
+    }
+}
+// SDK UnauthorizedContext carries the Response, not the rejected request token.
+// Pair them at the transport seam so late concurrent 401s cannot select a newer token.
+const rejectedAccess = new WeakMap();
+export function rejectedFungiMcpAccess(response) {
+    return rejectedAccess.get(response);
+}
+export function fungiMcpReachableFetch(endpoint, fetchImpl = fetch) {
+    return async (url, init) => {
+        const target = new URL(url instanceof Request ? url.url : String(url));
+        if (target.origin !== endpoint.origin)
+            throw new Error("Refusing an MCP request outside the selected origin");
+        try {
+            const response = await fetchImpl(url, { ...init, redirect: "error" });
+            const authorization = new Headers(init?.headers).get("Authorization");
+            if (response.status === 401 && authorization?.startsWith("Bearer "))
+                rejectedAccess.set(response, authorization.slice(7));
+            return response;
+        }
+        catch (cause) {
+            if (init?.signal?.aborted === true)
+                throw cause;
+            throw new FungiMcpUnreachableError(endpoint.origin, cause);
+        }
+    };
+}
+/**
+ * Add the existing Fungi MCP execute door to a Local run's capability scope.
+ * The remote server selects and authorizes permitted Team Computers per request.
+ * Computer discovery and operations remain inside the maintained execute door.
+ */
+export function createPrivateFungiMcpConnection(options) {
+    const endpoint = parseFungiMcpEndpoint(options.endpoint);
+    const fetch = fungiMcpReachableFetch(endpoint, options.fetch);
+    return {
+        id: "fungi-mcp",
+        acquire: async ({ signal, session }) => {
+            signal.throwIfAborted();
+            const client = new Client(fungiMcpClientInfo);
+            const forms = registerMcpFormElicitation(client, options.requestApproval, session?.sessionId);
+            const transportOptions = {
+                authProvider: options.authProvider,
+                fetch,
+                requestInit: { redirect: "error" },
+            };
+            const transport = new StreamableHTTPClientTransport(endpoint, transportOptions);
+            try {
+                await client.connect(transport, { signal });
+                signal.throwIfAborted();
+                return {
+                    snapshot: {
+                        version: "fungi-mcp-execute-v1",
+                        modules: [
+                            Mycelium.module({
+                                id: "fungi-mcp",
+                                name: "fungiMcp",
+                                description: "The explicitly connected Fungi MCP server.",
+                                operations: {
+                                    execute: Mycelium.operation({
+                                        replay: "unsafe",
+                                        description: "Execute JavaScript on the connected Fungi MCP server. Discover permitted Team Computer operations with await forage.search({query: 'read'}) and await forage.describe({path: 'files.read'}). Explicitly return the result. Returns the original MCP content and isError; it does not run on the local machine.",
+                                        input: z.strictObject({ code: z.string() }),
+                                        execute: async (input, context) => {
+                                            try {
+                                                return z
+                                                    .json()
+                                                    .parse(await forms.run(context.signal, (signal) => client.callTool({ name: "execute", arguments: input }, { signal })));
+                                            }
+                                            catch (cause) {
+                                                if (cause instanceof McpFormApprovalError)
+                                                    return {
+                                                        isError: true,
+                                                        content: [{ type: "text", text: cause.message }],
+                                                        structuredContent: {
+                                                            kind: cause.kind,
+                                                            reason: cause.reason,
+                                                        },
+                                                    };
+                                                // Report uncertainty as a failed MCP result so the caller
+                                                // can distinguish it from a successful remote result.
+                                                // Replaying arbitrary JavaScript here could duplicate work.
+                                                const httpFailure = z
+                                                    .looseObject({ status: z.number() })
+                                                    .safeParse(cause);
+                                                if (httpFailure.success &&
+                                                    httpFailure.data.status !== 401)
+                                                    throw cause;
+                                                // A 401 is the Hub refusing before execution: the
+                                                // outcome is known, and reconnecting will not help.
+                                                if (cause instanceof UnauthorizedError ||
+                                                    cause instanceof FungiSignInRequiredError ||
+                                                    (httpFailure.success &&
+                                                        httpFailure.data.status === 401))
+                                                    return {
+                                                        content: [
+                                                            {
+                                                                type: "text",
+                                                                text: `Fungi MCP refused this call because its sign-in or Team key is missing, expired or revoked; the code did not run. Run fungi login --fungi-mcp ${endpoint.href} or use a current key.`,
+                                                            },
+                                                        ],
+                                                        isError: true,
+                                                    };
+                                                return {
+                                                    content: [
+                                                        {
+                                                            type: "text",
+                                                            text: "Fungi MCP connection was interrupted during an operation; outcome unknown. Reconnect and inspect Computer state before retrying.",
+                                                        },
+                                                    ],
+                                                    isError: true,
+                                                };
+                                            }
+                                        },
+                                    }),
+                                },
+                            }),
+                        ],
+                    },
+                    release: () => {
+                        forms.close();
+                        return client.close();
+                    },
+                };
+            }
+            catch (error) {
+                forms.close();
+                await client.close();
+                if (error instanceof UnauthorizedError)
+                    throw error;
+                if (error instanceof FungiSignInRequiredError ||
+                    z.object({ status: z.literal(401) }).safeParse(error).success)
+                    throw new Error(`Fungi MCP sign-in is missing, expired or revoked; run fungi login --fungi-mcp ${endpoint.href}`, { cause: error });
+                throw error;
+            }
+        },
+    };
+}

package/dist/private-fungi-mcp-endpoint.d.ts

@@ -0,0 +1,2 @@
+/** The Team MCP address is HTTPS, except for an exact loopback host. */
+export declare function parseFungiMcpEndpoint(value: string | URL): URL;

package/dist/private-fungi-mcp-endpoint.js

@@ -0,0 +1,15 @@
+/** The Team MCP address is HTTPS, except for an exact loopback host. */
+export function parseFungiMcpEndpoint(value) {
+    const endpoint = new URL(value);
+    const loopback = endpoint.hostname === "localhost" ||
+        endpoint.hostname === "127.0.0.1" ||
+        endpoint.hostname === "[::1]";
+    if (!(endpoint.protocol === "https:" ||
+        (endpoint.protocol === "http:" && loopback)) ||
+        endpoint.username ||
+        endpoint.password ||
+        endpoint.search ||
+        endpoint.hash)
+        throw new Error("Fungi MCP requires HTTPS (or HTTP on an exact loopback host) without URL credentials, query or fragment");
+    return endpoint;
+}

package/dist/private-fungi-mcp-selection-schema.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+/** A project selects a target and auth kind; credential material stays with Local. */
+export declare const fungiMcpSelectionSchema: z.ZodObject<{
+    endpoint: z.ZodPipe<z.ZodURL, z.ZodString>;
+    authentication: z.ZodOptional<z.ZodLiteral<"oyster-key">>;
+}, z.core.$strict>;
+export type PrivateFungiMcpSelection = z.infer<typeof fungiMcpSelectionSchema>;

package/dist/private-fungi-mcp-selection-schema.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
+/** A project selects a target and auth kind; credential material stays with Local. */
+export const fungiMcpSelectionSchema = z.strictObject({
+    endpoint: z.url().pipe(z.string().refine((value) => {
+        try {
+            parseFungiMcpEndpoint(value);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }, "Fungi MCP requires HTTPS (or HTTP on an exact loopback host) without credentials, query or fragment")),
+    authentication: z.literal("oyster-key").optional(),
+});

package/dist/private-fungi-mcp-selection.d.ts

@@ -0,0 +1,14 @@
+import type { PrivateFungiMcpConnectionOptions } from "./private-fungi-mcp-connection.js";
+import { type PrivateFungiMcpSelection } from "./private-fungi-mcp-selection-schema.js";
+/** The service validates saved project selections with the RPC selection schema. */
+export declare function readProjectFungiMcpSelection(root: string): Promise<{
+    endpoint: string;
+    authentication?: "oyster-key" | undefined;
+} | undefined>;
+export declare function readFungiMcpSelection(selection: PrivateFungiMcpSelection, options?: {
+    credentialPath?: string;
+}): PrivateFungiMcpConnectionOptions;
+export declare function sameFungiMcpConnection(left: PrivateFungiMcpConnectionOptions | undefined, right: PrivateFungiMcpConnectionOptions): boolean;
+export declare class FungiMcpSelectionConflict extends Error {
+    constructor();
+}

package/dist/private-fungi-mcp-selection.js

@@ -0,0 +1,49 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { fungiMcpAccountAuth } from "./private-fungi-account.js";
+import { oysterMcpKeyAuth } from "./private-oyster-mcp-auth.js";
+import { fungiMcpSelectionSchema, } from "./private-fungi-mcp-selection-schema.js";
+/** The service validates saved project selections with the RPC selection schema. */
+export async function readProjectFungiMcpSelection(root) {
+    const path = join(root, ".fungi", "team-mcp.json");
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            return undefined;
+        throw cause;
+    }
+    try {
+        return fungiMcpSelectionSchema.parse(JSON.parse(text));
+    }
+    catch (cause) {
+        throw new Error(`${path}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    }
+}
+export function readFungiMcpSelection(selection, options = {}) {
+    const parsed = fungiMcpSelectionSchema.safeParse(selection);
+    if (!parsed.success)
+        throw new Error("Invalid Fungi MCP connection selection");
+    if (process.platform !== "linux" && process.platform !== "darwin")
+        throw new Error("Fungi MCP credential connections are supported only on Linux and macOS");
+    const endpoint = new URL(parsed.data.endpoint);
+    return {
+        endpoint,
+        authentication: parsed.data.authentication,
+        authProvider: parsed.data.authentication === "oyster-key"
+            ? oysterMcpKeyAuth(endpoint, options)
+            : fungiMcpAccountAuth(endpoint, options),
+    };
+}
+export function sameFungiMcpConnection(left, right) {
+    return (left?.endpoint.href === right.endpoint.href &&
+        left.authentication === right.authentication);
+}
+export class FungiMcpSelectionConflict extends Error {
+    constructor() {
+        super("This Local Agent already has a different Fungi MCP connection; stop the Local service before changing it");
+        this.name = "FungiMcpSelectionConflict";
+    }
+}

package/dist/private-fungi-model-api.d.ts

@@ -0,0 +1,6 @@
+import { type ProviderStreams, type FetchFunction } from "@earendil-works/pi-ai";
+export declare function assertFungiModelsEnabled(): void;
+/** Access tokens can only travel to the selected Team's two inference endpoints. */
+export declare function fungiModelFetch(baseUrl: string, teamName: string, fetchImpl?: FetchFunction, credentialPath?: string): FetchFunction;
+/** Pi owns streaming; this adapter owns Fungi's destination, incident policy and refusals. */
+export declare function createFungiModelApi(resolveTeamName: (baseUrl: string) => Promise<string>, credentialPath?: string): ProviderStreams;

package/dist/private-fungi-model-api.js

@@ -0,0 +1,125 @@
+import process from "node:process";
+import { fungiAccountFetch } from "./private-fungi-account.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
+import { FungiSignInRequiredError } from "./private-fungi-auth-error.js";
+import { hasApi, } from "@earendil-works/pi-ai";
+import { stream, streamSimple, } from "@earendil-works/pi-ai/api/openai-completions";
+import { loginAllowed, subscriptionKillSwitchFrom, } from "@fungi.computer/veil/model-credentials";
+import { z } from "zod";
+import { logEvent } from "./log-event.js";
+import { parseFungiMcpEndpoint } from "./private-fungi-mcp-endpoint.js";
+const refusalSchema = z.object({
+    error: z.object({ code: z.string().max(256), message: z.string().max(4096) }),
+});
+/** Re-check incident policy at dispatch, including in an already-open Local host. */
+function fungiModelsEnabled() {
+    return loginAllowed({
+        providerId: "fungi",
+        method: "subscription",
+        host: "local",
+        scope: "user",
+    }, subscriptionKillSwitchFrom(process.env.FUNGI_SUBSCRIPTION_KILL));
+}
+export function assertFungiModelsEnabled() {
+    if (!fungiModelsEnabled())
+        throw new Error("Fungi models are paused. Try again later.");
+}
+function httpRefusal(status, code, message) {
+    return Response.json({ error: { code, message, type: "fungi_error" } }, { status });
+}
+/** Map Hub refusal codes to actions without returning dependency bodies. */
+function modelRefusal(status, body, teamName) {
+    const refusal = refusalSchema.safeParse(body);
+    const code = refusal.success ? refusal.data.error.code : "unavailable";
+    let message = refusal.success
+        ? refusal.data.error.message
+        : "Fungi could not complete this request. Retry shortly.";
+    if (["invalid_token", "insufficient_scope"].includes(code) || status === 401)
+        message = "Sign in to Fungi again to use models";
+    else if (["insufficient_quota", "subscription_required"].includes(code))
+        message = `Add credits to ${teamName}`;
+    else if (status === 503)
+        message =
+            code === "paused"
+                ? "Fungi models are paused. Try again later."
+                : "Fungi is unreachable. Retry shortly.";
+    return Response.json({ error: { code, message, type: "fungi_error" } }, { status: status });
+}
+/** The parsed destination must stay in the selected Team, with no redirect authority. */
+function assertModelEndpoint(base, url) {
+    if (url.origin !== base.origin ||
+        url.search ||
+        url.hash ||
+        url.username ||
+        url.password ||
+        ![`${base.pathname}/models`, `${base.pathname}/chat/completions`].includes(url.pathname))
+        throw new Error("Fungi refused a model endpoint outside the selected Team");
+}
+/** Access tokens can only travel to the selected Team's two inference endpoints. */
+export function fungiModelFetch(baseUrl, teamName, fetchImpl = globalThis.fetch, credentialPath = capturePrivateLocalConfigRoot().credentialPath) {
+    const base = parseFungiMcpEndpoint(baseUrl);
+    if (!/^\/api\/v1\/teams\/[^/]+$/u.test(base.pathname))
+        throw new Error("Fungi model requests require a selected Team");
+    const accountOptions = {
+        fetch: fetchImpl,
+        credentialPath,
+    };
+    const accountFetch = fungiAccountFetch(base.origin, accountOptions);
+    const transport = async (input, init) => {
+        if (!fungiModelsEnabled())
+            return httpRefusal(503, "paused", "Fungi models are paused. Try again later.");
+        const url = new URL(input instanceof Request ? input.url : String(input));
+        assertModelEndpoint(base, url);
+        let response;
+        try {
+            response = await accountFetch(input, { ...init, redirect: "error" });
+        }
+        catch (cause) {
+            if (init?.signal?.aborted)
+                throw cause;
+            if (cause instanceof FungiSignInRequiredError)
+                return httpRefusal(401, "invalid_token", "Sign in to Fungi again to use models");
+            logEvent("fungi-model.request", cause);
+            return httpRefusal(503, "unavailable", "Fungi is unreachable. Retry when your Hub connection returns.");
+        }
+        if (response.ok)
+            return response;
+        let body;
+        try {
+            body = await response.json();
+        }
+        catch (cause) {
+            logEvent("fungi-model.refusal", cause);
+            return httpRefusal(503, "unavailable", "Fungi is unreachable or returned an unreadable refusal. Retry shortly.");
+        }
+        return modelRefusal(response.status, body, teamName);
+    };
+    return Object.assign(transport, { preconnect: fetchImpl.preconnect });
+}
+/** Pi owns streaming; this adapter owns Fungi's destination, incident policy and refusals. */
+export function createFungiModelApi(resolveTeamName, credentialPath = capturePrivateLocalConfigRoot().credentialPath) {
+    const fetchFor = (baseUrl, fetchImpl = globalThis.fetch) => Object.assign(async (input, init) => {
+        const teamName = await resolveTeamName(baseUrl);
+        return fungiModelFetch(baseUrl, teamName, fetchImpl, credentialPath)(input, init);
+    }, { preconnect: fetchImpl.preconnect });
+    return {
+        stream(model, context, options) {
+            if (!hasApi(model, "openai-completions"))
+                throw new Error("Fungi requires its compatible chat API");
+            return stream(model, context, {
+                ...options,
+                maxRetries: 0,
+                fetch: fetchFor(model.baseUrl, options?.fetch),
+            });
+        },
+        streamSimple(model, context, options) {
+            if (!hasApi(model, "openai-completions"))
+                throw new Error("Fungi requires its compatible chat API");
+            return streamSimple(model, context, {
+                ...options,
+                maxRetries: 0,
+                fetch: fetchFor(model.baseUrl, options?.fetch),
+            });
+        },
+    };
+}

package/dist/private-fungi-model-catalog.d.ts

@@ -0,0 +1,16 @@
+import type { Model } from "@earendil-works/pi-ai";
+import { z } from "zod";
+/** The thinking levels a Local model may offer. */
+export declare const thinkingLevelSchema: z.ZodEnum<{
+    minimal: "minimal";
+    low: "low";
+    medium: "medium";
+    high: "high";
+    xhigh: "xhigh";
+    max: "max";
+}>;
+export type FungiHostedModel = Model<"openai-completions"> & {
+    default: boolean;
+};
+/** Only the Hub's hosted rows become Local models; its Billing price owns the estimate. */
+export declare function fungiHostedModels(value: unknown, baseUrl: string): FungiHostedModel[];

package/dist/private-fungi-model-catalog.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+/** The thinking levels a Local model may offer. */
+export const thinkingLevelSchema = z.enum([
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]);
+const catalogSchema = z.object({
+    object: z.literal("list"),
+    data: z
+        .array(z.object({
+        id: z.string().min(1).max(256),
+        owned_by: z.string().min(1).max(256),
+        name: z.string().min(1).max(256),
+        context_window: z.number().int().positive(),
+        max_output_tokens: z.number().int().positive(),
+        reasoning_levels: z.array(thinkingLevelSchema).max(6),
+        input: z.array(z.literal("text")).length(1),
+        default: z.boolean(),
+        cost: z.object({
+            input: z.number().nonnegative(),
+            output: z.number().nonnegative(),
+            cacheRead: z.number().nonnegative(),
+            cacheWrite: z.number().nonnegative(),
+        }),
+    }))
+        .max(100),
+});
+/** Only the Hub's hosted rows become Local models; its Billing price owns the estimate. */
+export function fungiHostedModels(value, baseUrl) {
+    const rows = catalogSchema
+        .parse(value)
+        .data.filter((row) => row.owned_by === "fungi" && row.id.startsWith("@fungi/"));
+    if (rows.filter((row) => row.default).length !== 1 ||
+        new Set(rows.map((row) => row.id)).size !== rows.length)
+        throw new Error("Fungi returned an invalid hosted model catalog");
+    return rows.map((row) => {
+        const thinkingLevelMap = {
+            off: null,
+            minimal: null,
+            low: null,
+            medium: null,
+            high: null,
+            xhigh: null,
+            max: null,
+        };
+        for (const level of row.reasoning_levels)
+            thinkingLevelMap[level] = level;
+        return {
+            id: row.id,
+            name: row.name,
+            provider: "fungi",
+            api: "openai-completions",
+            baseUrl,
+            default: row.default,
+            input: row.input,
+            contextWindow: row.context_window,
+            maxTokens: row.max_output_tokens,
+            reasoning: row.reasoning_levels.length > 0,
+            thinkingLevelMap,
+            cost: row.cost,
+            compat: {
+                supportsStore: false,
+                supportsDeveloperRole: true,
+                supportsReasoningEffort: true,
+                supportsUsageInStreaming: true,
+                maxTokensField: "max_completion_tokens",
+                requiresToolResultName: false,
+                requiresAssistantAfterToolResult: false,
+                requiresThinkingAsText: true,
+                requiresReasoningContentOnAssistantMessages: false,
+                supportsStrictMode: false,
+                supportsOpenAIGrammarTools: false,
+                supportsMidConvoSystemMessages: false,
+                supportsMidConvoToolAdditions: false,
+                supportsLongCacheRetention: false,
+                sendSessionAffinityHeaders: false,
+                zaiToolStream: false,
+                thinkingFormat: "openai",
+            },
+        };
+    });
+}

package/dist/private-fungi-model-provider.d.ts

@@ -0,0 +1,6 @@
+import { type FetchFunction } from "@earendil-works/pi-ai";
+/** The selected account Team owns the endpoint; the Hub owns the live model catalog. */
+export declare function createFungiModelProvider(input?: {
+    credentialPath?: string;
+    fetch?: FetchFunction;
+}): import("@earendil-works/pi-ai").Provider<"openai-completions">;

package/dist/private-fungi-model-provider.js

@@ -0,0 +1,51 @@
+import { z } from "zod";
+import { createProvider } from "@earendil-works/pi-ai";
+import { createFungiAccountOAuth, fungiAccountTeam, readFungiAccountStatus, } from "./private-fungi-account.js";
+import { fungiHostedModels } from "./private-fungi-model-catalog.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
+import { assertFungiModelsEnabled, createFungiModelApi, fungiModelFetch, } from "./private-fungi-model-api.js";
+/** The selected account Team owns the endpoint; the Hub owns the live model catalog. */
+export function createFungiModelProvider(input = {}) {
+    const options = {
+        ...input,
+        credentialPath: input.credentialPath ?? capturePrivateLocalConfigRoot().credentialPath,
+    };
+    const oauth = createFungiAccountOAuth(options);
+    return createProvider({
+        id: "fungi",
+        name: "Fungi",
+        auth: { oauth },
+        models: [],
+        api: createFungiModelApi(async (baseUrl) => {
+            const status = await readFungiAccountStatus(options);
+            if (status?.team === undefined)
+                throw new Error("Sign in to Fungi to use models");
+            const currentBase = `${status.issuer}/api/v1/teams/${encodeURIComponent(status.team.teamId)}`;
+            if (currentBase !== baseUrl)
+                throw new Error("Fungi account changed before dispatch. Retry for your selected Team.");
+            return status.team.name;
+        }, options.credentialPath),
+        async fetchModels(context) {
+            assertFungiModelsEnabled();
+            if (context.credential?.type !== "oauth")
+                throw new Error("Sign in to Fungi to use models");
+            const auth = await oauth.toAuth(context.credential);
+            if (auth.baseUrl === undefined || auth.apiKey === undefined)
+                throw new Error("Choose a Team and sign in to Fungi to use models");
+            const team = fungiAccountTeam(context.credential);
+            const response = await fungiModelFetch(auth.baseUrl, team.name, options.fetch, options.credentialPath)(`${auth.baseUrl}/models`, {
+                headers: { Authorization: `Bearer ${auth.apiKey}` },
+                signal: AbortSignal.any([context.signal, AbortSignal.timeout(30_000)]),
+            });
+            if (!response.ok) {
+                const body = await response.json();
+                // The transport owns the curated refusal; Pi returns this failure to its caller.
+                const refusal = z
+                    .object({ error: z.object({ message: z.string() }) })
+                    .parse(body).error.message;
+                throw new Error(refusal);
+            }
+            return fungiHostedModels(await response.json(), auth.baseUrl);
+        },
+    });
+}

package/dist/private-fungi-pending-logouts.d.ts

@@ -0,0 +1,34 @@
+import { z } from "zod";
+declare const identitySchema: z.ZodObject<{
+    issuer: z.ZodURL;
+    userId: z.ZodString;
+    loginId: z.ZodString;
+}, z.core.$strict>;
+declare const detachSchema: z.ZodObject<{
+    teamId: z.ZodString;
+    computerId: z.ZodString;
+    requestId: z.ZodString;
+}, z.core.$strict>;
+export type PendingDetach = z.output<typeof detachSchema>;
+declare const recordSchema: z.ZodObject<{
+    issuer: z.ZodURL;
+    userId: z.ZodString;
+    loginId: z.ZodString;
+    revoke: z.ZodBoolean;
+    detaches: z.ZodArray<z.ZodObject<{
+        teamId: z.ZodString;
+        computerId: z.ZodString;
+        requestId: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type PendingLogout = z.output<typeof recordSchema>;
+export type LoginIdentity = z.output<typeof identitySchema>;
+/** Decode only routing metadata. These IDs never authorize a revocation. */
+export declare function loginIdentity(issuer: string, access: string): LoginIdentity | undefined;
+/** Durable logout intent, separate from the credential that logout destroys. */
+export declare function pendingLogouts(credentialPath: string): {
+    remember(identity: LoginIdentity, detaches: PendingDetach[]): Promise<void>;
+    confirmed(identity: LoginIdentity, detach?: PendingDetach): Promise<void>;
+    forAccount(identity: LoginIdentity): Promise<PendingLogout[]>;
+};
+export {};