@pencil-agent/nano-pencil 2.0.0-beta.2 → 2.0.0-beta.3

package/dist/node_modules/@pencil-agent/ai/dist/cli.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+/**
+ * [WHO]: OAuth CLI tool for managing AI provider credentials
+ * [FROM]: Depends on node:fs, readline, oauth utils
+ * [TO]: Consumed by core/lib/ai/src/index.ts
+ * [HERE]: core/lib/ai/src/cli.ts - AI package CLI
+ */
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { createInterface } from "readline";
+import { getOAuthProvider, getOAuthProviders } from "./utils/oauth/index.js";
+const AUTH_FILE = "auth.json";
+const PROVIDERS = getOAuthProviders();
+function prompt(rl, question) {
+    return new Promise((resolve) => rl.question(question, resolve));
+}
+function loadAuth() {
+    if (!existsSync(AUTH_FILE))
+        return {};
+    try {
+        return JSON.parse(readFileSync(AUTH_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function saveAuth(auth) {
+    writeFileSync(AUTH_FILE, JSON.stringify(auth, null, 2), "utf-8");
+}
+async function login(providerId) {
+    const provider = getOAuthProvider(providerId);
+    if (!provider) {
+        console.error(`Unknown provider: ${providerId}`);
+        process.exit(1);
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    const promptFn = (msg) => prompt(rl, `${msg} `);
+    try {
+        const credentials = await provider.login({
+            onAuth: (info) => {
+                console.log(`\nOpen this URL in your browser:\n${info.url}`);
+                if (info.instructions)
+                    console.log(info.instructions);
+                console.log();
+            },
+            onPrompt: async (p) => {
+                return await promptFn(`${p.message}${p.placeholder ? ` (${p.placeholder})` : ""}:`);
+            },
+            onProgress: (msg) => console.log(msg),
+        });
+        const auth = loadAuth();
+        auth[providerId] = { type: "oauth", ...credentials };
+        saveAuth(auth);
+        console.log(`\nCredentials saved to ${AUTH_FILE}`);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (!command || command === "help" || command === "--help" || command === "-h") {
+        const providerList = PROVIDERS.map((p) => `  ${p.id.padEnd(20)} ${p.name}`).join("\n");
+        console.log(`Usage: npx @pencil-agent/ai <command> [provider]
+
+Commands:
+  login [provider]  Login to an OAuth provider
+  list              List available providers
+
+Providers:
+${providerList}
+
+Examples:
+  npx @pencil-agent/ai login              # interactive provider selection
+  npx @pencil-agent/ai login anthropic    # login to specific provider
+  npx @pencil-agent/ai list               # list providers
+`);
+        return;
+    }
+    if (command === "list") {
+        console.log("Available OAuth providers:\n");
+        for (const p of PROVIDERS) {
+            console.log(`  ${p.id.padEnd(20)} ${p.name}`);
+        }
+        return;
+    }
+    if (command === "login") {
+        let provider = args[1];
+        if (!provider) {
+            const rl = createInterface({ input: process.stdin, output: process.stdout });
+            console.log("Select a provider:\n");
+            for (let i = 0; i < PROVIDERS.length; i++) {
+                console.log(`  ${i + 1}. ${PROVIDERS[i].name}`);
+            }
+            console.log();
+            const choice = await prompt(rl, `Enter number (1-${PROVIDERS.length}): `);
+            rl.close();
+            const index = parseInt(choice, 10) - 1;
+            if (index < 0 || index >= PROVIDERS.length) {
+                console.error("Invalid selection");
+                process.exit(1);
+            }
+            provider = PROVIDERS[index].id;
+        }
+        if (!PROVIDERS.some((p) => p.id === provider)) {
+            console.error(`Unknown provider: ${provider}`);
+            console.error(`Use 'npx @pencil-agent/ai list' to see available providers`);
+            process.exit(1);
+        }
+        console.log(`Logging in to ${provider}...`);
+        await login(provider);
+        return;
+    }
+    console.error(`Unknown command: ${command}`);
+    console.error(`Use 'npx @pencil-agent/ai --help' for usage`);
+    process.exit(1);
+}
+main().catch((err) => {
+    console.error("Error:", err.message);
+    process.exit(1);
+});

package/dist/node_modules/@pencil-agent/ai/dist/config-path.d.ts

@@ -0,0 +1 @@
+export declare function getDebugLogPath(): string;

package/dist/node_modules/@pencil-agent/ai/dist/config-path.js

@@ -0,0 +1,17 @@
+/**
+ * [WHO]: getDebugLogPath function - returns path to debug log file
+ * [FROM]: Depends on node:os, node:path
+ * [TO]: Consumed by ./debug-logger.ts, ai package internals
+ * [HERE]: core/lib/ai/src/config-path.ts - debug log path utility
+ */
+import { homedir } from "os";
+import { join } from "path";
+export function getDebugLogPath() {
+    // Check for environment variable override
+    const envDir = process.env.NANOPENCIL_CODING_AGENT_DIR;
+    if (envDir) {
+        const dir = envDir === "~" ? homedir() : envDir.startsWith("~/") ? homedir() + envDir.slice(1) : envDir;
+        return join(dir, "nanopencil-debug.log");
+    }
+    return join(homedir(), ".nanopencil", "agent", "nanopencil-debug.log");
+}

package/dist/node_modules/@pencil-agent/ai/dist/debug-logger.d.ts

@@ -0,0 +1,94 @@
+export type DebugLogLevel = "error" | "warn" | "info" | "debug" | "trace";
+interface DebugLoggerOptions {
+    enabled?: boolean;
+    level?: DebugLogLevel;
+    maxFileSize?: number;
+}
+declare class DebugLogger {
+    private enabled;
+    private level;
+    private maxFileSize;
+    private logPath;
+    constructor(options?: DebugLoggerOptions);
+    /**
+     * Detect if debug logging is enabled from environment
+     */
+    private detectEnabled;
+    /**
+     * Detect log level from environment
+     */
+    private detectLevel;
+    /**
+     * Enable or disable logging at runtime
+     */
+    setEnabled(enabled: boolean): void;
+    /**
+     * Set log level at runtime
+     */
+    setLevel(level: DebugLogLevel): void;
+    /**
+     * Re-check environment variables (for when they change after initialization)
+     */
+    refreshFromEnv(): void;
+    /**
+     * Check if a specific level is enabled
+     */
+    private isLevelEnabled;
+    /**
+     * Write a log entry to file
+     */
+    private writeLog;
+    /**
+     * Rotate log file if it exceeds max size
+     */
+    private rotateIfNeeded;
+    error(category: string, message: string, data?: unknown): void;
+    warn(category: string, message: string, data?: unknown): void;
+    info(category: string, message: string, data?: unknown): void;
+    debug(category: string, message: string, data?: unknown): void;
+    trace(category: string, message: string, data?: unknown): void;
+    /**
+     * Log AI provider request
+     */
+    logProviderRequest(provider: string, model: string, request: unknown): void;
+    /**
+     * Log AI provider response chunk (for streaming)
+     */
+    logProviderChunk(provider: string, model: string, chunk: unknown): void;
+    /**
+     * Log AI provider response (non-streaming)
+     */
+    logProviderResponse(provider: string, model: string, response: unknown): void;
+    /**
+     * Log content parsing events
+     */
+    logContentParse(operation: string, input: unknown, output?: unknown): void;
+    /**
+     * Log TUI rendering events
+     */
+    logTUI(operation: string, details?: unknown): void;
+    /**
+     * Get the log file path
+     */
+    getLogPath(): string;
+    /**
+     * Clear the log file
+     */
+    clear(): void;
+}
+export declare function getDebugLogger(): DebugLogger;
+export declare function createDebugLogger(options: DebugLoggerOptions): DebugLogger;
+export declare const debug: {
+    error: (category: string, message: string, data?: unknown) => void;
+    warn: (category: string, message: string, data?: unknown) => void;
+    info: (category: string, message: string, data?: unknown) => void;
+    debug: (category: string, message: string, data?: unknown) => void;
+    trace: (category: string, message: string, data?: unknown) => void;
+    logProviderRequest: (provider: string, model: string, request: unknown) => void;
+    logProviderChunk: (provider: string, model: string, chunk: unknown) => void;
+    logProviderResponse: (provider: string, model: string, response: unknown) => void;
+    logContentParse: (operation: string, input: unknown, output?: unknown) => void;
+    getLogPath: () => string;
+    clear: () => void;
+};
+export {};

package/dist/node_modules/@pencil-agent/ai/dist/debug-logger.js

@@ -0,0 +1,218 @@
+/**
+ * [WHO]: DebugLogger class, debug logging system for AI provider troubleshooting
+ * [FROM]: Depends on node:fs, node:path, ./config-path
+ * [TO]: Consumed by ai package providers for logging
+ * [HERE]: core/lib/ai/src/debug-logger.ts - debug logging for nanopencil AI providers
+ */
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { getDebugLogPath } from "./config-path.js";
+const LOG_LEVELS = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    trace: 4,
+};
+class DebugLogger {
+    enabled;
+    level;
+    maxFileSize;
+    logPath;
+    constructor(options = {}) {
+        this.enabled = options.enabled ?? this.detectEnabled();
+        this.level = LOG_LEVELS[options.level ?? this.detectLevel()];
+        this.maxFileSize = options.maxFileSize ?? 10 * 1024 * 1024; // 10MB
+        this.logPath = getDebugLogPath();
+    }
+    /**
+     * Detect if debug logging is enabled from environment
+     */
+    detectEnabled() {
+        return (process.env.NANOPENCIL_DEBUG === "1" ||
+            process.env.DEBUG?.includes("nanopencil") ||
+            false);
+    }
+    /**
+     * Detect log level from environment
+     */
+    detectLevel() {
+        const level = process.env.NANOPENCIL_DEBUG_LEVEL;
+        if (level && level in LOG_LEVELS) {
+            return level;
+        }
+        return "info";
+    }
+    /**
+     * Enable or disable logging at runtime
+     */
+    setEnabled(enabled) {
+        this.enabled = enabled;
+    }
+    /**
+     * Set log level at runtime
+     */
+    setLevel(level) {
+        this.level = LOG_LEVELS[level];
+    }
+    /**
+     * Re-check environment variables (for when they change after initialization)
+     */
+    refreshFromEnv() {
+        this.enabled = this.detectEnabled();
+        this.level = LOG_LEVELS[this.detectLevel()];
+    }
+    /**
+     * Check if a specific level is enabled
+     */
+    isLevelEnabled(level) {
+        // Re-check environment on each log call to handle late-set env vars
+        if (!this.enabled && process.env.NANOPENCIL_DEBUG === "1") {
+            this.refreshFromEnv();
+        }
+        return this.enabled && LOG_LEVELS[level] <= this.level;
+    }
+    /**
+     * Write a log entry to file
+     */
+    writeLog(level, category, message, data) {
+        if (!this.isLevelEnabled(level))
+            return;
+        const timestamp = new Date().toISOString();
+        const levelStr = level.toUpperCase().padStart(5);
+        let logLine = `[${timestamp}] [${levelStr}] [${category}] ${message}`;
+        if (data !== undefined) {
+            try {
+                const dataStr = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+                logLine += `\n${dataStr}`;
+            }
+            catch {
+                logLine += `\n[Unable to serialize data]`;
+            }
+        }
+        logLine += "\n";
+        try {
+            // Ensure directory exists
+            const dir = dirname(this.logPath);
+            if (!existsSync(dir)) {
+                mkdirSync(dir, { recursive: true });
+            }
+            // Check file size and rotate if needed
+            this.rotateIfNeeded();
+            appendFileSync(this.logPath, logLine);
+        }
+        catch {
+            // Silently fail - debug logging should never break the app
+        }
+    }
+    /**
+     * Rotate log file if it exceeds max size
+     */
+    rotateIfNeeded() {
+        try {
+            const { statSync, renameSync, existsSync } = require("fs");
+            if (existsSync(this.logPath)) {
+                const stats = statSync(this.logPath);
+                if (stats.size > this.maxFileSize) {
+                    const backupPath = `${this.logPath}.old`;
+                    if (existsSync(backupPath)) {
+                        require("fs").unlinkSync(backupPath);
+                    }
+                    renameSync(this.logPath, backupPath);
+                }
+            }
+        }
+        catch {
+            // Ignore rotation errors
+        }
+    }
+    // Public logging methods
+    error(category, message, data) {
+        this.writeLog("error", category, message, data);
+    }
+    warn(category, message, data) {
+        this.writeLog("warn", category, message, data);
+    }
+    info(category, message, data) {
+        this.writeLog("info", category, message, data);
+    }
+    debug(category, message, data) {
+        this.writeLog("debug", category, message, data);
+    }
+    trace(category, message, data) {
+        this.writeLog("trace", category, message, data);
+    }
+    /**
+     * Log AI provider request
+     */
+    logProviderRequest(provider, model, request) {
+        this.debug("AI", `Request to ${provider}/${model}`, request);
+    }
+    /**
+     * Log AI provider response chunk (for streaming)
+     */
+    logProviderChunk(provider, model, chunk) {
+        this.trace("AI", `Chunk from ${provider}/${model}`, chunk);
+    }
+    /**
+     * Log AI provider response (non-streaming)
+     */
+    logProviderResponse(provider, model, response) {
+        this.debug("AI", `Response from ${provider}/${model}`, response);
+    }
+    /**
+     * Log content parsing events
+     */
+    logContentParse(operation, input, output) {
+        this.trace("PARSE", operation, { input, output });
+    }
+    /**
+     * Log TUI rendering events
+     */
+    logTUI(operation, details) {
+        this.trace("TUI", operation, details);
+    }
+    /**
+     * Get the log file path
+     */
+    getLogPath() {
+        return this.logPath;
+    }
+    /**
+     * Clear the log file
+     */
+    clear() {
+        try {
+            const { writeFileSync } = require("fs");
+            writeFileSync(this.logPath, "");
+        }
+        catch {
+            // Ignore clear errors
+        }
+    }
+}
+// Singleton instance
+let globalLogger = null;
+export function getDebugLogger() {
+    if (!globalLogger) {
+        globalLogger = new DebugLogger();
+    }
+    return globalLogger;
+}
+export function createDebugLogger(options) {
+    return new DebugLogger(options);
+}
+// Export singleton methods for convenience
+export const debug = {
+    error: (category, message, data) => getDebugLogger().error(category, message, data),
+    warn: (category, message, data) => getDebugLogger().warn(category, message, data),
+    info: (category, message, data) => getDebugLogger().info(category, message, data),
+    debug: (category, message, data) => getDebugLogger().debug(category, message, data),
+    trace: (category, message, data) => getDebugLogger().trace(category, message, data),
+    logProviderRequest: (provider, model, request) => getDebugLogger().logProviderRequest(provider, model, request),
+    logProviderChunk: (provider, model, chunk) => getDebugLogger().logProviderChunk(provider, model, chunk),
+    logProviderResponse: (provider, model, response) => getDebugLogger().logProviderResponse(provider, model, response),
+    logContentParse: (operation, input, output) => getDebugLogger().logContentParse(operation, input, output),
+    getLogPath: () => getDebugLogger().getLogPath(),
+    clear: () => getDebugLogger().clear(),
+};

package/dist/node_modules/@pencil-agent/ai/dist/env-api-keys.d.ts

@@ -0,0 +1,8 @@
+import type { KnownProvider } from "./types.js";
+/**
+ * Get API key for provider from known environment variables, e.g. OPENAI_API_KEY.
+ *
+ * Will not return API keys for providers that require OAuth tokens.
+ */
+export declare function getEnvApiKey(provider: KnownProvider): string | undefined;
+export declare function getEnvApiKey(provider: string): string | undefined;

package/dist/node_modules/@pencil-agent/ai/dist/env-api-keys.js

@@ -0,0 +1,107 @@
+/**
+ * [WHO]: Environment-based API key utilities
+ * [FROM]: Depends on node:fs, node:os, node:path (lazy loaded)
+ * [TO]: Consumed by core/lib/ai/src/index.ts
+ * [HERE]: core/lib/ai/src/env-api-keys.ts - environment variable key access
+ */
+// NEVER convert to top-level imports - breaks browser/Vite builds (web-ui)
+let _existsSync = null;
+let _homedir = null;
+let _join = null;
+// Eagerly load in Node.js/Bun environment only
+if (typeof process !== "undefined" && (process.versions?.node || process.versions?.bun)) {
+    import("node:fs").then((m) => {
+        _existsSync = m.existsSync;
+    });
+    import("node:os").then((m) => {
+        _homedir = m.homedir;
+    });
+    import("node:path").then((m) => {
+        _join = m.join;
+    });
+}
+let cachedVertexAdcCredentialsExists = null;
+function hasVertexAdcCredentials() {
+    if (cachedVertexAdcCredentialsExists === null) {
+        // If node modules haven't loaded yet (async import race at startup),
+        // return false WITHOUT caching so the next call retries once they're ready.
+        // Only cache false permanently in a browser environment where fs is never available.
+        if (!_existsSync || !_homedir || !_join) {
+            const isNode = typeof process !== "undefined" && (process.versions?.node || process.versions?.bun);
+            if (!isNode) {
+                // Definitively in a browser — safe to cache false permanently
+                cachedVertexAdcCredentialsExists = false;
+            }
+            return false;
+        }
+        // Check GOOGLE_APPLICATION_CREDENTIALS env var first (standard way)
+        const gacPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+        if (gacPath) {
+            cachedVertexAdcCredentialsExists = _existsSync(gacPath);
+        }
+        else {
+            // Fall back to default ADC path (lazy evaluation)
+            cachedVertexAdcCredentialsExists = _existsSync(_join(_homedir(), ".config", "gcloud", "application_default_credentials.json"));
+        }
+    }
+    return cachedVertexAdcCredentialsExists;
+}
+export function getEnvApiKey(provider) {
+    // Fall back to environment variables
+    if (provider === "github-copilot") {
+        return process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN;
+    }
+    // ANTHROPIC_OAUTH_TOKEN takes precedence over ANTHROPIC_API_KEY
+    if (provider === "anthropic") {
+        return process.env.ANTHROPIC_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY;
+    }
+    // Vertex AI uses Application Default Credentials, not API keys.
+    // Auth is configured via `gcloud auth application-default login`.
+    if (provider === "google-vertex") {
+        const hasCredentials = hasVertexAdcCredentials();
+        const hasProject = !!(process.env.GOOGLE_CLOUD_PROJECT || process.env.GCLOUD_PROJECT);
+        const hasLocation = !!process.env.GOOGLE_CLOUD_LOCATION;
+        if (hasCredentials && hasProject && hasLocation) {
+            return "<authenticated>";
+        }
+    }
+    if (provider === "amazon-bedrock") {
+        // Amazon Bedrock supports multiple credential sources:
+        // 1. AWS_PROFILE - named profile from ~/.aws/credentials
+        // 2. AWS_ACCESS_KEY_ID + AWS_SECRET_ACCESS_KEY - standard IAM keys
+        // 3. AWS_BEARER_TOKEN_BEDROCK - Bedrock API keys (bearer token)
+        // 4. AWS_CONTAINER_CREDENTIALS_RELATIVE_URI - ECS task roles
+        // 5. AWS_CONTAINER_CREDENTIALS_FULL_URI - ECS task roles (full URI)
+        // 6. AWS_WEB_IDENTITY_TOKEN_FILE - IRSA (IAM Roles for Service Accounts)
+        if (process.env.AWS_PROFILE ||
+            (process.env.AWS_ACCESS_KEY_ID && process.env.AWS_SECRET_ACCESS_KEY) ||
+            process.env.AWS_BEARER_TOKEN_BEDROCK ||
+            process.env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI ||
+            process.env.AWS_CONTAINER_CREDENTIALS_FULL_URI ||
+            process.env.AWS_WEB_IDENTITY_TOKEN_FILE) {
+            return "<authenticated>";
+        }
+    }
+    const envMap = {
+        openai: "OPENAI_API_KEY",
+        "azure-openai-responses": "AZURE_OPENAI_API_KEY",
+        google: "GEMINI_API_KEY",
+        groq: "GROQ_API_KEY",
+        cerebras: "CEREBRAS_API_KEY",
+        xai: "XAI_API_KEY",
+        openrouter: "OPENROUTER_API_KEY",
+        "vercel-ai-gateway": "AI_GATEWAY_API_KEY",
+        zai: "ZAI_API_KEY",
+        mistral: "MISTRAL_API_KEY",
+        minimax: "MINIMAX_API_KEY",
+        "minimax-cn": "MINIMAX_CN_API_KEY",
+        huggingface: "HF_TOKEN",
+        opencode: "OPENCODE_API_KEY",
+        "opencode-go": "OPENCODE_API_KEY",
+        "kimi-coding": "KIMI_API_KEY",
+        "ali-token-plan-openai": "ALI_TOKEN_PLAN_API_KEY",
+        "ali-token-plan-anthropic": "ALI_TOKEN_PLAN_API_KEY",
+    };
+    const envVar = envMap[provider];
+    return envVar ? process.env[envVar] : undefined;
+}

package/dist/node_modules/@pencil-agent/ai/dist/env.d.ts

@@ -0,0 +1,7 @@
+/**
+ * [WHO]: getEnvApiKey
+ * [FROM]: Depends on env-api-keys for environment/provider API key lookup
+ * [TO]: Consumed by @pencil-agent/ai/env subpath consumers
+ * [HERE]: core/lib/ai/src/env.ts - additive env helper subpath entry for AI package
+ */
+export { getEnvApiKey } from "./env-api-keys.js";

package/dist/node_modules/@pencil-agent/ai/dist/env.js

@@ -0,0 +1,7 @@
+/**
+ * [WHO]: getEnvApiKey
+ * [FROM]: Depends on env-api-keys for environment/provider API key lookup
+ * [TO]: Consumed by @pencil-agent/ai/env subpath consumers
+ * [HERE]: core/lib/ai/src/env.ts - additive env helper subpath entry for AI package
+ */
+export { getEnvApiKey } from "./env-api-keys.js";

package/dist/node_modules/@pencil-agent/ai/dist/events.d.ts

@@ -0,0 +1,8 @@
+/**
+ * [WHO]: EventStream, AssistantMessageEventStream, createAssistantMessageEventStream, AsyncEventStream
+ * [FROM]: Depends on AI event stream implementation and structural event stream types
+ * [TO]: Consumed by @pencil-agent/ai/events subpath consumers
+ * [HERE]: core/lib/ai/src/events.ts - additive events subpath entry for AI package
+ */
+export * from "./utils/event-stream.js";
+export type * from "./utils/event-stream-types.js";

package/dist/node_modules/@pencil-agent/ai/dist/events.js

@@ -0,0 +1,7 @@
+/**
+ * [WHO]: EventStream, AssistantMessageEventStream, createAssistantMessageEventStream, AsyncEventStream
+ * [FROM]: Depends on AI event stream implementation and structural event stream types
+ * [TO]: Consumed by @pencil-agent/ai/events subpath consumers
+ * [HERE]: core/lib/ai/src/events.ts - additive events subpath entry for AI package
+ */
+export * from "./utils/event-stream.js";

package/dist/node_modules/@pencil-agent/ai/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * [WHO]: AI package barrel exports
+ * [FROM]: Depends on typebox, all providers
+ * [TO]: Consumed by core/lib/ai/src/index.ts
+ * [HERE]: core/lib/ai/src/index.ts - AI package entry point
+ */
+export type { Static, TSchema } from "@sinclair/typebox";
+export { Type } from "@sinclair/typebox";
+export * from "./api-registry.js";
+export * from "./env-api-keys.js";
+export * from "./models.js";
+export * from "./providers/anthropic.js";
+export * from "./providers/azure-openai-responses.js";
+export * from "./providers/google.js";
+export * from "./providers/google-gemini-cli.js";
+export * from "./providers/google-vertex.js";
+export * from "./providers/openai-completions.js";
+export * from "./providers/openai-responses.js";
+export * from "./providers/register-builtins.js";
+export * from "./stream.js";
+export * from "./types.js";
+export * from "./utils/event-stream.js";
+export * from "./utils/json-parse.js";
+export * from "./utils/oauth/index.js";
+export * from "./utils/overflow.js";
+export * from "./utils/typebox-helpers.js";
+export * from "./utils/validation.js";

package/dist/node_modules/@pencil-agent/ai/dist/index.js

@@ -0,0 +1,20 @@
+export { Type } from "@sinclair/typebox";
+export * from "./api-registry.js";
+export * from "./env-api-keys.js";
+export * from "./models.js";
+export * from "./providers/anthropic.js";
+export * from "./providers/azure-openai-responses.js";
+export * from "./providers/google.js";
+export * from "./providers/google-gemini-cli.js";
+export * from "./providers/google-vertex.js";
+export * from "./providers/openai-completions.js";
+export * from "./providers/openai-responses.js";
+export * from "./providers/register-builtins.js";
+export * from "./stream.js";
+export * from "./types.js";
+export * from "./utils/event-stream.js";
+export * from "./utils/json-parse.js";
+export * from "./utils/oauth/index.js";
+export * from "./utils/overflow.js";
+export * from "./utils/typebox-helpers.js";
+export * from "./utils/validation.js";

package/dist/node_modules/@pencil-agent/ai/dist/json.d.ts

@@ -0,0 +1,7 @@
+/**
+ * [WHO]: parseStreamingJson
+ * [FROM]: Depends on streaming JSON parser utility
+ * [TO]: Consumed by @pencil-agent/ai/json subpath consumers
+ * [HERE]: core/lib/ai/src/json.ts - additive JSON helper subpath entry for AI package
+ */
+export * from "./utils/json-parse.js";

package/dist/node_modules/@pencil-agent/ai/dist/json.js

@@ -0,0 +1,7 @@
+/**
+ * [WHO]: parseStreamingJson
+ * [FROM]: Depends on streaming JSON parser utility
+ * [TO]: Consumed by @pencil-agent/ai/json subpath consumers
+ * [HERE]: core/lib/ai/src/json.ts - additive JSON helper subpath entry for AI package
+ */
+export * from "./utils/json-parse.js";