@cortexkit/pi-anthropic-auth 1.23.0 → 2.0.1

package/dist/convert.js

@@ -1,5 +1,5 @@
-import { applyClaudeCodeMetadata, applyMidConversationOutputConfig, applyThinkingBindingControls, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING, CLAUDE_OPUS_5_5_ADAPTIVE_THINKING, CLAUDE_OPUS_5_ADAPTIVE_THINKING, CLAUDE_SONNET_5_ADAPTIVE_THINKING, ClaudeCodeFirstUserTextTracker, isClaudeFableOrMythos5Model, isClaudeOpus5Model, isClaudeOpus55Model, isClaudeSonnet5Model, isFastModeSupportedModel, isOpenAIReasoningSignature, orderClaudeCodeBody, signRequestBody, } from '@cortexkit/anthropic-auth-core';
-import { collapseSystemMessages, getCurrentSystemPrompt, getCurrentTools, normalizeContext, } from '@earendil-works/pi-ai';
+import { applyClaudeCodeMetadata, applyMidConversationOutputConfig, applyThinkingBindingControls, assertNoMeaningfulTrailingAssistant, buildBillingHeaderValue, CLAUDE_CODE_ENTRYPOINT, CLAUDE_CODE_IDENTITY, CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING, CLAUDE_HAIKU_5_5_ADAPTIVE_THINKING, CLAUDE_OPUS_5_5_ADAPTIVE_THINKING, CLAUDE_OPUS_5_ADAPTIVE_THINKING, CLAUDE_SONNET_5_5_ADAPTIVE_THINKING, CLAUDE_SONNET_5_ADAPTIVE_THINKING, ClaudeCodeFirstUserTextTracker, isClaudeFableOrMythos5Model, isClaudeHaiku55Model, isClaudeOpus5Model, isClaudeOpus55Model, isClaudeSonnet5Model, isClaudeSonnet55Model, isFastModeSupportedModel, isOpenAIReasoningSignature, orderClaudeCodeBody, signRequestBody, stripEmptyTrailingAssistantMessages, } from '@cortexkit/anthropic-auth-core';
+import { collapseSystemMessages, getCurrentSystemPrompt, getCurrentTools, normalizeContext, } from './transcript.js';
 // Anchor identifying Pi's documentation paragraph — the only part of the prompt
 // that Anthropic currently rejects in system[]. Unknown prompt shapes take the
 // service-preserving fallback below instead of returning the full prompt there.
@@ -433,9 +433,10 @@ function applyCacheMode(body, enabled, mode) {
     });
 }
 export async function buildAnthropicRequest(modelId, context, options, cache, fastModeEnabled = false, identity, controls = {}) {
-    // Pi 0.86 passes a normalized transcript to providers. Resolve instructions,
-    // named sections and tool changes through its own replay helpers; raw host
-    // prompts (including ordered OMP blocks) still enter through normalization.
+    // Pi 0.86 passes a normalized transcript to providers, and later system
+    // messages can change the prompt, its named sections and the tool set. Resolve
+    // them through the local replay port; raw host prompts (including ordered OMP
+    // blocks) still enter through normalization.
     const transcript = collapseSystemMessages(normalizeContext({
         ...context,
         systemPrompt: systemPromptText(context.systemPrompt),
@@ -445,12 +446,12 @@ export async function buildAnthropicRequest(modelId, context, options, cache, fa
         systemPrompt: getCurrentSystemPrompt(transcript.messages),
         tools: getCurrentTools(transcript.messages),
     };
+    // Conversion can discard opaque or incomplete blocks. Check context.messages
+    // first so those losses cannot hide a meaningful final assistant turn. Check
+    // the Anthropic messages again after conversion removes empty user messages.
+    assertNoMeaningfulTrailingAssistant(context.messages);
     const messages = convertMessages(context.messages, modelId);
-    // Strip trailing assistant messages — Anthropic rejects prefill on some models
-    while (messages.length &&
-        messages[messages.length - 1]?.role === 'assistant') {
-        messages.pop();
-    }
+    stripEmptyTrailingAssistantMessages(messages);
     const system = [
         {
             type: 'text',
@@ -507,18 +508,23 @@ export async function buildAnthropicRequest(modelId, context, options, cache, fa
     }
     const isFableOrMythos5 = isClaudeFableOrMythos5Model(modelId);
     const isSonnet5 = isClaudeSonnet5Model(modelId);
+    const isSonnet55 = isClaudeSonnet55Model(modelId);
+    const isHaiku55 = isClaudeHaiku55Model(modelId);
     const isOpus5 = isClaudeOpus5Model(modelId);
     const isOpus55 = isClaudeOpus55Model(modelId);
-    // Sonnet 5, Opus 5, and Opus 5.5 share Fable/Mythos's adaptive-summarized contract: make
-    // adaptive thinking visible (display defaults to "omitted") and map reasoning
-    // to output_config effort. Pi's typed options cannot express
-    // thinking-disabled, so there is no disable case here (see transform.ts for
-    // the raw-body path). Each model refs its own per-family constant —
-    // families can diverge, so the constant rather than a shared alias keeps
-    // the call sites explicit.
+    // Request summaries so the host can display adaptive reasoning.
+    // Pi's typed options cannot express the disabled-thinking setting;
+    // OpenCode handles it by transforming the raw request body. Separate model
+    // constants let each model's thinking configuration change independently.
     if (isFableOrMythos5) {
         body.thinking = { ...CLAUDE_FABLE_MYTHOS_5_SUMMARIZED_THINKING };
     }
+    else if (isHaiku55) {
+        body.thinking = { ...CLAUDE_HAIKU_5_5_ADAPTIVE_THINKING };
+    }
+    else if (isSonnet55) {
+        body.thinking = { ...CLAUDE_SONNET_5_5_ADAPTIVE_THINKING };
+    }
     else if (isSonnet5) {
         body.thinking = { ...CLAUDE_SONNET_5_ADAPTIVE_THINKING };
     }
@@ -529,7 +535,15 @@ export async function buildAnthropicRequest(modelId, context, options, cache, fa
         body.thinking = { ...CLAUDE_OPUS_5_ADAPTIVE_THINKING };
     }
     if (options?.reasoning) {
-        if (isFableOrMythos5 || isSonnet5 || isOpus5 || isOpus55) {
+        if ((isSonnet55 || isHaiku55) && options.reasoning === 'minimal') {
+            throw new Error(`${isHaiku55 ? 'Claude Haiku 5.5' : 'Claude Sonnet 5.5'} does not support minimal effort`);
+        }
+        if (isFableOrMythos5 ||
+            isSonnet5 ||
+            isSonnet55 ||
+            isHaiku55 ||
+            isOpus5 ||
+            isOpus55) {
             body.output_config = { effort: options.reasoning };
         }
         else {
@@ -557,5 +571,8 @@ export async function buildAnthropicRequest(modelId, context, options, cache, fa
     }
     const unsigned = JSON.stringify(orderClaudeCodeBody(body));
     const bodyText = await signRequestBody(unsigned);
-    return { body, bodyText };
+    // The stream decoder must use the exact tool set that produced this body.
+    // Pi 0.86's transcript has no top-level context.tools, and normalizing it
+    // again after dispatch would duplicate work and risk a different mapping.
+    return { body, bodyText, hostTools: context.tools ?? [] };
 }

package/dist/custody.d.ts

@@ -1,4 +1,4 @@
-import { type AccountCommandResult, type ClaustrumEnrollmentStatus, type ClaustrumMode, type ClaustrumScopedClient } from '@cortexkit/anthropic-auth-core';
+import { type AccountCommandResult, type ClaustrumEnrollmentStatus, type ClaustrumMode } from '@cortexkit/anthropic-auth-core';
 export declare function requirePiEnrollment(): Promise<{
     state: 'approved';
     proposedName: string;
@@ -10,8 +10,4 @@ export interface PiCustodyCommands {
     status(): Promise<ClaustrumEnrollmentStatus>;
     reset(): Promise<AccountCommandResult>;
 }
-export declare function createPiCustodyCommands(options: {
-    reconfigure: () => Promise<void>;
-    storagePath?: string;
-    connect?: () => Promise<ClaustrumScopedClient>;
-}): PiCustodyCommands;
+export declare function createPiCustodyCommands(): PiCustodyCommands;

package/dist/custody.js

@@ -1,5 +1,4 @@
-import { CLAUSTRUM_PI_ENROLLMENT_NAME, ClaustrumScopedCustody, connectClaustrumScopedClient, getHostClaustrumEnrollmentPaths, readClaustrumEnrollmentStatus, resetClaustrumEnrollmentState, setClaustrumModePersistent, } from '@cortexkit/anthropic-auth-core';
-import { getPiAccountStoragePath, getPiClaustrumConnectionOptions, hasPiLocalAnthropicOAuth, } from './paths.js';
+import { CLAUSTRUM_PI_ENROLLMENT_NAME, getHostClaustrumEnrollmentPaths, readClaustrumEnrollmentStatus, resetClaustrumEnrollmentState, } from '@cortexkit/anthropic-auth-core';
 export async function requirePiEnrollment() {
     const status = await readClaustrumEnrollmentStatus(getHostClaustrumEnrollmentPaths('pi'), CLAUSTRUM_PI_ENROLLMENT_NAME);
     if (status.state !== 'approved' ||
@@ -8,8 +7,7 @@ export async function requirePiEnrollment() {
     }
     return status;
 }
-export function createPiCustodyCommands(options) {
-    const storagePath = options.storagePath ?? getPiAccountStoragePath();
+export function createPiCustodyCommands() {
     const paths = () => getHostClaustrumEnrollmentPaths('pi');
     return {
         status: () => readClaustrumEnrollmentStatus(paths(), CLAUSTRUM_PI_ENROLLMENT_NAME),
@@ -25,41 +23,10 @@ export function createPiCustodyCommands(options) {
             return { text: messages[result] };
         },
         async transition(mode) {
-            if (mode === 'claustrum') {
-                if (await hasPiLocalAnthropicOAuth()) {
-                    return {
-                        text: 'Refused: Pi still has a local Anthropic OAuth credential. Run `bunx @cortexkit/opencode-anthropic-auth setup` to approve its removal and enable Claustrum.',
-                    };
-                }
-                // A slash command never invokes the administrative CLI or approves itself.
-                // Existing enrollment and grants must be verified before committing mode.
-                await requirePiEnrollment();
-                const client = await (options.connect?.() ??
-                    connectClaustrumScopedClient(getPiClaustrumConnectionOptions(storagePath)));
-                const custody = new ClaustrumScopedCustody({
-                    client,
-                    tokenPath: paths().tokenPath,
-                });
-                try {
-                    const inventory = await custody.discover();
-                    const active = inventory.accounts.filter((account) => account.state === 'active');
-                    if (!active.length)
-                        return {
-                            text: 'Refused: Claustrum has no accessible active Anthropic accounts.',
-                        };
-                    for (const account of active)
-                        await custody.authorize(account);
-                }
-                finally {
-                    custody.close();
-                }
-            }
-            await setClaustrumModePersistent(mode, storagePath);
-            await options.reconfigure();
+            // Mode changes can remove host credentials and require offline consent.
+            // A menu never enrolls, grants custody or writes the authority journal.
             return {
-                text: mode === 'claustrum'
-                    ? 'Pi now uses Claustrum for Anthropic authentication.'
-                    : 'Pi now uses local Anthropic authentication. Use /login anthropic if needed.',
+                text: `Refused: Changing Pi authentication to ${mode} requires offline setup. Run \`bunx @cortexkit/opencode-anthropic-auth setup\` and review the migration and host OAuth removal consent.`,
             };
         },
     };

package/dist/index.d.ts

@@ -1,6 +1,5 @@
-import { type ClaustrumScopedClient } from '@cortexkit/anthropic-auth-core';
+import { type NativeCustodyClient } from '@cortexkit/anthropic-auth-core';
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 export default function cortexKitPiAnthropicAuth(pi: ExtensionAPI, options?: {
-    connectScoped?: () => Promise<ClaustrumScopedClient>;
-    pollIntervalMs?: number;
+    connectScoped?: () => Promise<NativeCustodyClient>;
 }): Promise<void>;

package/dist/index.js

@@ -1,54 +1,43 @@
-import { authorize, CLAUDE_FABLE_MYTHOS_5_1_PRICING, CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW, CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS, CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS, CLAUDE_FABLE_MYTHOS_5_PRICING, exchange, getClaustrumMode, isClaudeFableOrMythos51Model, loadAccounts, refreshClaudeOAuthToken, } from '@cortexkit/anthropic-auth-core';
+import { CLAUDE_FABLE_MYTHOS_5_1_PRICING, CLAUDE_FABLE_MYTHOS_5_CONTEXT_WINDOW, CLAUDE_FABLE_MYTHOS_5_MAX_OUTPUT_TOKENS, CLAUDE_FABLE_MYTHOS_5_MODEL_SPECS, CLAUDE_FABLE_MYTHOS_5_PRICING, CLAUDE_HAIKU_5_5_CONTEXT_WINDOW, CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING, CLAUDE_HAIKU_5_5_LONG_CONTEXT_THRESHOLD, CLAUDE_HAIKU_5_5_MAX_OUTPUT_TOKENS, CLAUDE_HAIKU_5_5_MODEL_ID, CLAUDE_HAIKU_5_5_PRICING, CLAUDE_SONNET_5_5_CONTEXT_WINDOW, CLAUDE_SONNET_5_5_MAX_OUTPUT_TOKENS, CLAUDE_SONNET_5_5_MODEL_ID, CLAUDE_SONNET_5_5_PRICING, isClaudeFableOrMythos51Model, readNativeEnrollmentMode, } from '@cortexkit/anthropic-auth-core';
 import { registerCommands } from './commands.js';
-import { createPiCustodyCommands, requirePiEnrollment } from './custody.js';
 import { collectPiEffortHistory, deriveContextEntries, } from './effort-history.js';
-import { getPiAccountStoragePath } from './paths.js';
-import { closePiScopedRuntime, getPiScopedRuntime, streamCortexKitAnthropic, } from './stream.js';
-async function assertLocalAuthentication() {
-    if (getClaustrumMode(await loadAccounts(getPiAccountStoragePath())) ===
-        'claustrum') {
-        throw new Error('Local Anthropic login and refresh are disabled while Claustrum custody is active');
-    }
-}
-async function loginAnthropic(callbacks) {
-    await assertLocalAuthentication();
-    const auth = await authorize('max');
-    callbacks.onAuth({ url: auth.url });
-    const callback = await callbacks.onPrompt({
-        message: 'Paste the Claude OAuth callback URL or code:',
-    });
-    const result = await exchange(callback, auth.verifier, auth.redirectUri, auth.state);
-    if (result.type !== 'success') {
-        throw new Error('Anthropic OAuth exchange failed');
-    }
-    await assertLocalAuthentication();
-    return {
-        refresh: result.refresh,
-        access: result.access,
-        expires: result.expires,
-    };
-}
+import { closePiNativeRuntime, getPiNativeRuntime, isNativeMigrationRequired, } from './native.js';
+import { createPiNativeCommands } from './native-commands.js';
+import { getPiAccountStoragePath, requirePiNativeHostAuth } from './paths.js';
+import { streamCortexKitAnthropic } from './stream.js';
 function textImageInput() {
     return ['text', 'image'];
 }
-async function refreshAnthropicToken(credentials) {
-    await assertLocalAuthentication();
-    const refreshed = await refreshClaudeOAuthToken({
-        refreshToken: credentials.refresh,
+/**
+ * Refuses every Anthropic prompt with Core's migration message. Registered
+ * only when startup found an install that offline setup has never migrated.
+ * Pi checks a prompt's credentials after its input handlers run. Handling the
+ * input here stops it before that check, which would otherwise answer with
+ * Pi's generic missing-key text for a 1.x install whose Pi login is still
+ * stored. Extension commands such as /claude run before input handlers, so
+ * they stay reachable.
+ */
+function refuseUnmigratedPrompts(pi, storagePath) {
+    pi.on('input', async (_event, ctx) => {
+        // Prompts for other providers do not use this install's accounts.
+        if (ctx.model?.provider !== 'anthropic')
+            return { action: 'continue' };
+        const refusal = await getPiNativeRuntime(storagePath).migrationRefusal();
+        if (!refusal)
+            return { action: 'continue' };
+        if (ctx.hasUI)
+            ctx.ui.notify(refusal.message, 'error');
+        else
+            process.stderr.write(`${refusal.message}\n`);
+        return { action: 'handled' };
     });
-    return {
-        refresh: refreshed.refresh,
-        access: refreshed.access,
-        expires: refreshed.expires,
-    };
 }
 export default async function cortexKitPiAnthropicAuth(pi, options = {}) {
     const storagePath = getPiAccountStoragePath();
-    registerCommands(pi, createPiCustodyCommands({
-        storagePath,
-        reconfigure: configureProvider,
-        connect: options.connectScoped,
-    }));
+    getPiNativeRuntime(storagePath, {
+        ...(options.connectScoped && { connect: options.connectScoped }),
+    });
+    registerCommands(pi, createPiNativeCommands(storagePath));
     const effortHistoryBySession = new Map();
     pi.on('turn_start', async (_event, ctx) => {
         const sessionId = ctx.sessionManager.getSessionId();
@@ -86,7 +75,7 @@ export default async function cortexKitPiAnthropicAuth(pi, options = {}) {
         const sessionId = ctx.sessionManager.getSessionId();
         if (sessionId)
             effortHistoryBySession.delete(sessionId);
-        closePiScopedRuntime(storagePath);
+        await closePiNativeRuntime(storagePath);
     });
     const configuration = {
         name: 'Anthropic (CortexKit OAuth)',
@@ -166,47 +155,120 @@ export default async function cortexKitPiAnthropicAuth(pi, options = {}) {
                 contextWindow: 1_000_000,
                 maxTokens: 128_000,
             },
+            {
+                id: CLAUDE_HAIKU_5_5_MODEL_ID,
+                name: 'Claude Haiku 5.5',
+                reasoning: true,
+                thinkingLevelMap: {
+                    off: null,
+                    minimal: null,
+                    xhigh: 'xhigh',
+                    max: 'max',
+                },
+                input: textImageInput(),
+                cost: {
+                    input: CLAUDE_HAIKU_5_5_PRICING.input,
+                    output: CLAUDE_HAIKU_5_5_PRICING.output,
+                    cacheRead: CLAUDE_HAIKU_5_5_PRICING.cacheRead,
+                    cacheWrite: CLAUDE_HAIKU_5_5_PRICING.cacheWrite5m,
+                    tiers: [
+                        {
+                            inputTokensAbove: CLAUDE_HAIKU_5_5_LONG_CONTEXT_THRESHOLD,
+                            input: CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING.input,
+                            output: CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING.output,
+                            cacheRead: CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING.cacheRead,
+                            cacheWrite: CLAUDE_HAIKU_5_5_LONG_CONTEXT_PRICING.cacheWrite5m,
+                        },
+                    ],
+                },
+                contextWindow: CLAUDE_HAIKU_5_5_CONTEXT_WINDOW,
+                maxTokens: CLAUDE_HAIKU_5_5_MAX_OUTPUT_TOKENS,
+            },
+            {
+                id: CLAUDE_SONNET_5_5_MODEL_ID,
+                name: 'Claude Sonnet 5.5',
+                reasoning: true,
+                thinkingLevelMap: {
+                    off: null,
+                    minimal: null,
+                    xhigh: 'xhigh',
+                    max: 'max',
+                },
+                input: textImageInput(),
+                cost: {
+                    input: CLAUDE_SONNET_5_5_PRICING.input,
+                    output: CLAUDE_SONNET_5_5_PRICING.output,
+                    cacheRead: CLAUDE_SONNET_5_5_PRICING.cacheRead,
+                    cacheWrite: CLAUDE_SONNET_5_5_PRICING.cacheWrite5m,
+                },
+                contextWindow: CLAUDE_SONNET_5_5_CONTEXT_WINDOW,
+                maxTokens: CLAUDE_SONNET_5_5_MAX_OUTPUT_TOKENS,
+            },
         ],
-        oauth: {
-            name: 'Anthropic Claude Pro/Max (CortexKit)',
-            login: loginAnthropic,
-            refreshToken: refreshAnthropicToken,
-            getApiKey: (credentials) => credentials.access,
-        },
         streamSimple: (model, context, options) => streamCortexKitAnthropic(model, context, options, options?.sessionId
             ? effortHistoryBySession.get(options.sessionId)
             : undefined),
     };
     async function configureProvider() {
-        if (getClaustrumMode(await loadAccounts(storagePath)) !== 'claustrum') {
-            closePiScopedRuntime(storagePath);
-            pi.registerProvider('anthropic', configuration);
-            return;
-        }
         const streamSimple = configuration.streamSimple;
         if (!streamSimple)
             throw new Error('Anthropic stream implementation is unavailable');
+        // Register vault-backed models even if no account can serve yet, so a
+        // repaired enrollment or re-login takes effect on the next request. Local
+        // credentials still require completed offline migration before serving.
+        const startupMode = await readNativeEnrollmentMode('pi').catch(() => undefined);
+        try {
+            if (startupMode === 'local')
+                await getPiNativeRuntime(storagePath).view();
+        }
+        catch (error) {
+            // An install that offline setup has never migrated, such as a 1.x
+            // install upgraded in place, must still load: a failed load drops the
+            // /claude menu and Pi exits at startup. Its prompts are refused instead.
+            // Any other failure stops the load as before.
+            const refusal = await getPiNativeRuntime(storagePath).migrationRefusal();
+            if (!refusal)
+                throw error;
+            refuseUnmigratedPrompts(pi, storagePath);
+        }
         const configured = async () => {
-            if (getClaustrumMode(await loadAccounts(storagePath)) !== 'claustrum')
-                return false;
-            await requirePiEnrollment();
-            return true;
+            const mode = await readNativeEnrollmentMode('pi').catch(() => undefined);
+            if (mode !== 'local')
+                return true;
+            await requirePiNativeHostAuth();
+            let snapshot;
+            try {
+                snapshot = await (await getPiNativeRuntime(storagePath).service()).read();
+            }
+            catch (error) {
+                // An unmigrated install still reports the provider as configured, so
+                // Pi keeps its Anthropic models selectable and its prompts reach the
+                // refusal above (or, from any other caller, the stream, which refuses
+                // with the same Core message). If this check threw instead, Pi would
+                // record the refusal as a startup availability error.
+                if (isNativeMigrationRequired(error))
+                    return true;
+                throw error;
+            }
+            return snapshot.accounts.some((account) => account.type === 'oauth' &&
+                account.enabled &&
+                (account.source !== 'vault' || account.state === 'active'));
         };
         const provider = {
             id: 'anthropic',
-            name: 'Anthropic (Claustrum)',
+            name: 'Anthropic (CortexKit Native)',
             baseUrl: 'https://api.anthropic.com',
             auth: {
                 // Native ambient auth avoids fake keys and local OAuth refresh. Pi refuses
                 // a leftover stored OAuth credential because this provider has no OAuth
                 // handler; setup must obtain consent before removing that local entry.
                 apiKey: {
-                    name: 'Claustrum',
+                    name: 'CortexKit Native',
                     check: async () => (await configured())
-                        ? { type: 'api_key', source: 'Claustrum' }
+                        ? { type: 'api_key', source: 'CortexKit Native' }
                         : undefined,
                     resolve: async () => (await configured())
-                        ? { auth: {}, source: 'Claustrum' }
+                        ? { auth: {}, source: 'CortexKit Native' }
                         : undefined,
                 },
             },
@@ -221,12 +283,6 @@ export default async function cortexKitPiAnthropicAuth(pi, options = {}) {
             streamSimple,
         };
         pi.registerProvider(provider);
-        getPiScopedRuntime(storagePath, {
-            ...(options.connectScoped && { connect: options.connectScoped }),
-            ...(options.pollIntervalMs !== undefined && {
-                pollIntervalMs: options.pollIntervalMs,
-            }),
-        }).start();
     }
     await configureProvider();
 }

package/dist/native-commands.d.ts

@@ -0,0 +1,2 @@
+import type { PiNativeCommands } from './commands.ts';
+export declare function createPiNativeCommands(storagePath?: string): PiNativeCommands;