@botconnector/bccli 0.4.0 → 0.4.1

package/dist/{mcpCli-QUV5SD64.js → mcpCli-SNBDUWJN.js}

@@ -2,20 +2,20 @@
 import {
   CATALOG,
   fillTemplate
-} from "./chunk-BQ2IGPBR.js";
+} from "./chunk-WI22M2ID.js";
 import {
   authorizeMcpServer,
   clearTokens
-} from "./chunk-7F3IWBPQ.js";
+} from "./chunk-MFHCQQEN.js";
 import {
   addGlobalServer,
   globalMcpPath,
   readMcpFile,
   removeGlobalServer
-} from "./chunk-L7QI6JN2.js";
+} from "./chunk-24JN75FZ.js";
 import {
   bccliHome
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-FLQPE4S5.js";
 import {
   t
 } from "./chunk-UZWJQF67.js";
@@ -25,7 +25,7 @@ async function runMcpCommand(args, deps) {
   const home = bccliHome(deps.env);
   const [action = "list", name] = args.subArgs;
   if (action === "serve") {
-    const { runMcpServe } = await import("./serve-6QLBJUYW.js");
+    const { runMcpServe } = await import("./serve-KWOECK5W.js");
     return runMcpServe(args, deps);
   }
   const installed = readMcpFile(globalMcpPath(home));

package/dist/mcpCli.d.ts

@@ -0,0 +1,3 @@
+import type { CliArgs } from './args';
+import type { CliDeps } from './providerCli';
+export declare function runMcpCommand(args: CliArgs, deps: CliDeps): Promise<number>;

package/dist/mcpServer/serve.d.ts

@@ -0,0 +1,8 @@
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { CliArgs } from '../args';
+import type { CliDeps } from '../providerCli';
+export interface McpServeDeps extends CliDeps {
+    /** Test seam: replaces the stdio transport (pass an InMemoryTransport half). */
+    transport?: Transport;
+}
+export declare function runMcpServe(args: CliArgs, deps: McpServeDeps): Promise<number>;

package/dist/mcpServer/server.d.ts

@@ -0,0 +1,19 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type FetchToolOptions } from '../tools/fetch';
+export interface McpServerDeps {
+    /** BotConnector API base, e.g. https://api.botconnector.id/v1 (no trailing slash). */
+    baseUrl: string;
+    /** Bearer key for paid endpoints (bc_chat); never logged or echoed. */
+    apiKey: string;
+    /** Default model id for bc_chat (provider prefix already stripped). */
+    defaultModel: string;
+    /** Injectable for tests; defaults to global fetch. */
+    fetchFn?: typeof fetch;
+    /** Injectable clock for the catalog cache; defaults to Date.now. */
+    now?: () => number;
+    /** Keenable endpoint for bc_search fallback; undefined = the public keyless endpoint. */
+    keenableURL?: string;
+    /** Passed to createFetchTool (DNS lookup / page fetch injection for tests). */
+    fetchTool?: FetchToolOptions;
+}
+export declare function createMcpServer(deps: McpServerDeps): McpServer;

package/dist/models.d.ts

@@ -0,0 +1,13 @@
+import { type Config } from './config';
+export interface ModelGroup {
+    providerId: string;
+    providerName: string;
+    models: string[];
+    error?: string;
+}
+export declare function listAllModels(config: Config, env?: NodeJS.ProcessEnv, opts?: {
+    fetch?: typeof fetch;
+    timeoutMs?: number;
+    only?: string;
+    keyOverride?: string;
+}): Promise<ModelGroup[]>;

package/dist/{modelsCli-TRRB5LX4.js → modelsCli-CZ2HNGKR.js}

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 import {
   listAllModels
-} from "./chunk-XBO5GACQ.js";
-import "./chunk-SPRNLS7K.js";
-import "./chunk-PUN4HMAG.js";
+} from "./chunk-75BECX4F.js";
+import "./chunk-JHPGOAXU.js";
+import "./chunk-WNACAUDK.js";
 import "./chunk-BLOYFIAD.js";
 import {
   loadConfig,
   resolveModel
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-FLQPE4S5.js";
 import {
   t
 } from "./chunk-UZWJQF67.js";

package/dist/modelsCli.d.ts

@@ -0,0 +1,15 @@
+import type { CliArgs } from './args';
+export interface ModelsDeps {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    out(line: string): void;
+    err(line: string): void;
+    fetch?: typeof fetch;
+}
+/**
+ * `bccli models [provider|provider/model]`.
+ * No argument keeps the old behavior: list the models of the active provider.
+ * A provider id (or a full model ref, whose provider part is used) lists exactly
+ * that provider, even when it is keyless or comes from the project config.
+ */
+export declare function runModelsCommand(args: CliArgs, deps: ModelsDeps): Promise<number>;

package/dist/npmRunner.d.ts

@@ -0,0 +1,21 @@
+import { spawnSync } from 'node:child_process';
+/**
+ * Synchronous npm runner. On Windows it NEVER goes through cmd.exe: npm's own
+ * npm.cmd is just a shim around `node …\node_modules\npm\bin\npm-cli.js`, so we
+ * invoke that script with process.execPath and pass every argument as plain
+ * argv. Shell metacharacters in the prefix path (& % ( ) spaces, …) therefore
+ * need no quoting at all — nothing is ever joined into a command line.
+ */
+export interface NpmRunResult {
+    code: number;
+    stderr: string;
+    stdout?: string;
+}
+export interface RunNpmOptions {
+    platform?: NodeJS.Platform;
+    spawn?: typeof spawnSync;
+    env?: NodeJS.ProcessEnv;
+    exists?: (path: string) => boolean;
+    execPath?: string;
+}
+export declare function runNpmSync(prefix: string, argv: string[], opts?: RunNpmOptions): NpmRunResult;

package/dist/oauthLogin.d.ts

@@ -0,0 +1,47 @@
+export declare const OPENROUTER_AUTH_URL = "https://openrouter.ai/auth";
+export declare const OPENROUTER_EXCHANGE_URL = "https://openrouter.ai/api/v1/auth/keys";
+export declare const OPENROUTER_DASHBOARD_URL = "https://openrouter.ai/settings/keys";
+export declare const OPENROUTER_ENV_KEY = "OPENROUTER_API_KEY";
+export declare function pkcePair(): {
+    verifier: string;
+    challenge: string;
+};
+/** Varian tanpa redirect per docs resmi OpenRouter: kode ditampilkan untuk di-copy. */
+export declare function buildAuthUrl(challenge: string): string;
+export declare function redact(text: string, secrets: string[]): string;
+export declare function classifyExchange403(detail: string): 'expired' | 'rejected';
+export type ExchangeResult = {
+    ok: true;
+    key: string;
+} | {
+    ok: false;
+    kind: 'timeout' | 'network' | 'cancelled' | 'http403-expired' | 'http403-rejected' | 'http-other' | 'invalid-body';
+    status?: number;
+    detail: string;
+};
+export declare function exchangeAuthCode(code: string, verifier: string, deps: {
+    fetch: typeof fetch;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}): Promise<ExchangeResult>;
+/** Balasan readLine saat Ctrl+C pada mode test; di produksi readLine exit 130 langsung. */
+export declare const ABORT: unique symbol;
+export interface OauthLoginDeps {
+    out(s: string): void;
+    err(s: string): void;
+    env: NodeJS.ProcessEnv;
+    isTTY: boolean;
+    open(url: string): void;
+    readLine(prompt: string): Promise<string | typeof ABORT>;
+    saveCredential(id: string, key: string): void;
+    fetch: typeof fetch;
+    timeoutMs?: number;
+}
+export declare function runOauthLogin(deps: OauthLoginDeps): Promise<number>;
+export interface OauthLogoutDeps {
+    out(s: string): void;
+    err(s: string): void;
+    env: NodeJS.ProcessEnv;
+    removeCredential(id: string): boolean;
+}
+export declare function runOauthLogout(deps: OauthLogoutDeps): Promise<number>;

package/dist/permissions.d.ts

@@ -0,0 +1,30 @@
+import type { PermissionMode } from './config';
+import type { PermissionKind } from './tools/types';
+export interface PermissionRequest {
+    tool: string;
+    kind: PermissionKind;
+    target: string;
+}
+export type Decision = 'allow' | 'deny' | 'ask';
+export declare const MODE_ORDER: PermissionMode[];
+export declare function nextMode(mode: PermissionMode): PermissionMode;
+export declare function requiresSensitiveToolApproval(req: PermissionRequest): boolean;
+export declare class Permissions {
+    mode: PermissionMode;
+    private readonly cwd;
+    private readonly rules;
+    private readonly configRules;
+    constructor(mode: PermissionMode, rules?: string[], cwd?: string);
+    /** Edits may only be auto-allowed inside the project and outside .git. */
+    private editInProject;
+    /** Rules that "[a] allow for this session" would add; undefined when it must always be asked. */
+    rulesFor(req: PermissionRequest): string[] | undefined;
+    check(req: PermissionRequest): Decision;
+    list(): {
+        rule: string;
+        source: 'config' | 'session';
+    }[];
+    /** Removes a session grant; rules from config/flags stay until the user edits them. */
+    revoke(rule: string): void;
+    allowForSession(req: PermissionRequest): void;
+}

package/dist/pluginSpec.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Strict npm spec parsing and managed-entry validation for `bccli plugins`.
+ * Pure module — no filesystem or process access.
+ */
+export interface ParsedSpec {
+    /** Package name without the @version/@tag suffix; scope preserved. */
+    name: string;
+    /** The original (trimmed) spec, safe to hand to npm argv. */
+    spec: string;
+}
+/**
+ * Parses an npm install spec. Rejects URLs, git+ssh/github:/file: refs, local
+ * paths, flag-like arguments (leading '-'), uppercase, spaces/metachars and
+ * npm ranges (^, ~). Returns null when anything is off.
+ */
+export declare function parseNpmSpec(raw: string): ParsedSpec | null;
+/** Canonical config entry for a managed package (a config STRING, never join()). */
+export declare function managedEntry(name: string): string;
+export declare function isManagedEntry(entry: string): boolean;
+/**
+ * Strict validation of a managed entry: canonical prefix + bare npm name suffix.
+ * Returns the bare name, or null when the entry is not managed or is malformed
+ * (malformed entries must never be handed to npm).
+ */
+export declare function managedEntryName(entry: string): string | null;

package/dist/plugins.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { type Config } from './config';
+import type { HookEvent } from './hooks';
+import type { Tool, ToolContext, ToolResult } from './tools/types';
+export type PluginPayload = {
+    tool?: string;
+    input?: unknown;
+    output?: string;
+};
+/** What a plugin may do at load time. `config` is the read-only view of the loaded config. */
+export interface PluginContext {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    config: Readonly<Config>;
+    registerTool(tool: PluginTool): void;
+    /** Observe-only in v1: handlers run in order, errors are logged and never break the session. */
+    on(event: HookEvent, handler: (payload: PluginPayload) => void | Promise<void>): void;
+    log(message: string): void;
+}
+/** A tool as declared by a plugin; schema/kind/target get safe defaults. */
+export interface PluginTool {
+    name: string;
+    description: string;
+    schema?: z.ZodType;
+    kind?: Tool['kind'];
+    target?: (input: unknown) => string;
+    run(input: never, ctx: ToolContext): Promise<ToolResult>;
+}
+export interface LoadedPlugins {
+    tools: Tool[];
+    emit(event: HookEvent, payload?: PluginPayload): Promise<void>;
+}
+/**
+ * Loads the plugins listed in the global config (trusted). Specs may be absolute paths,
+ * `./`-relative to the config home, or bare package specifiers. Every failure — missing
+ * file, syntax error, bad activation, name collision — throws ConfigError so a broken
+ * plugin is visible immediately instead of silently missing.
+ */
+export declare function loadPlugins(specs: string[], opts: {
+    home: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    config: Config;
+    builtinNames: string[];
+}): LoadedPlugins;

package/dist/{pluginsCli-GNW4TPVV.js → pluginsCli-LPIUUDWB.js}

@@ -2,7 +2,7 @@
 import {
   bccliHome,
   globalConfigPath
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-FLQPE4S5.js";
 import {
   t
 } from "./chunk-UZWJQF67.js";

package/dist/pluginsCli.d.ts

@@ -0,0 +1,16 @@
+import type { CliArgs } from './args';
+export interface PluginsDeps {
+    out(s: string): void;
+    err(s: string): void;
+    env: NodeJS.ProcessEnv;
+    /** argv = argumen setelah npm (mis. ['install','foo']). Prefix = <home>/plugins. */
+    runNpm(prefix: string, argv: string[]): Promise<{
+        code: number;
+        stderr: string;
+    }>;
+    readPlugins(): string[];
+    savePlugins(entries: string[]): void;
+}
+/** Minimal package.json so `npm install --prefix` behaves deterministically. */
+export declare function ensurePrefixDir(prefix: string): void;
+export declare function runPluginsCommand(args: CliArgs, deps: PluginsDeps): Promise<number>;

package/dist/prCli.d.ts

@@ -0,0 +1,33 @@
+export interface PrCliArgs {
+    subArgs: string[];
+    cwd: string;
+    /** Set only when the user asked for `bccli pr … --allow-all`. */
+    allowAll?: boolean;
+}
+export interface PrDeps {
+    out(line: string): void;
+    err?(line: string): void;
+    /** gh argv runner (no shell). Defaults to `gh` on PATH. */
+    gh?(argv: string[]): Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    /** Run the agent task after checkout (injectable for tests). */
+    runTask?(opts: {
+        prompt?: string;
+        allowAll: boolean;
+        cwd: string;
+    }): Promise<number>;
+}
+/** argv for the child running the PR task; `--allow-all` only when the user asked for it. */
+export declare function prTaskArgv(entry: string, opts: {
+    prompt?: string;
+    allowAll?: boolean;
+}): string[];
+/**
+ * `bccli pr <number> [--repo owner/name] [task]` — check out a GitHub PR
+ * with `gh pr checkout`, then run an optional task on the checked-out branch.
+ * Read-only: never pushes, merges, or comments.
+ */
+export declare function runPrCommand(args: PrCliArgs, deps: PrDeps): Promise<number>;

package/dist/presets.d.ts

@@ -0,0 +1,8 @@
+export interface ProviderPreset {
+    id: string;
+    name: string;
+    baseURL: string;
+    apiKeyEnv?: string;
+    local?: boolean;
+}
+export declare const PRESETS: ProviderPreset[];

package/dist/print.d.ts

@@ -0,0 +1,14 @@
+import type { Runtime } from './setup';
+interface Writer {
+    write(s: string): unknown;
+}
+export declare function toolLabel(tool: string): string;
+export type OutputFormat = 'text' | 'json' | 'stream-json';
+export declare function runPrint(rt: Runtime, prompt: string, io?: {
+    out: Writer;
+    err: Writer;
+}, opts?: {
+    allowAll?: boolean;
+    outputFormat?: OutputFormat;
+}): Promise<number>;
+export {};

package/dist/provider.d.ts

@@ -0,0 +1,140 @@
+import OpenAI from 'openai';
+import { ResponsesWS } from 'openai/resources/responses/ws';
+import type { ResponseOutputItem } from 'openai/resources/responses/responses';
+import { type ReasoningLevel } from './reasoning';
+import type { ToolDefinition } from './tools/index';
+import type { ImageAttachment } from './tools/types';
+export interface ResponsesProgramCaller {
+    type: 'program';
+    caller_id: string;
+}
+export interface ToolCall {
+    id: string;
+    name: string;
+    arguments: string;
+    caller?: ResponsesProgramCaller;
+}
+export type ContentPart = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image_url';
+    image_url: {
+        url: string;
+    };
+};
+export type ChatMessage = {
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: string | ContentPart[];
+} | {
+    role: 'assistant';
+    content: string | null;
+    tool_calls?: {
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+        caller?: ResponsesProgramCaller;
+    }[];
+    /** Exact OpenAI Responses output items for stateless Luna replay/reconnect. Hidden from normal UI/export. */
+    responses_output_items?: ResponseOutputItem[];
+} | {
+    role: 'tool';
+    tool_call_id: string;
+    content: string;
+    /** Program caller linkage must be round-tripped for PTC continuation. */
+    responses_caller?: ResponsesProgramCaller;
+};
+export interface Usage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedInputTokens?: number;
+    cacheWriteTokens?: number;
+}
+export interface Completion {
+    text: string;
+    toolCalls: ToolCall[];
+    /** Exact OpenAI Responses output items, preserved for store:false replay. */
+    responsesOutputItems?: ResponseOutputItem[];
+    /** The model's reasoning, when it sends any (reasoning_content or <think> blocks); not part of the history. */
+    thinking?: string;
+    usage?: Usage;
+    finishReason?: string;
+}
+export interface ChatRequest {
+    messages: ChatMessage[];
+    tools?: ToolDefinition[];
+    /** Local-only allowlist for read-only PTC-safe tools; never serialized to Chat Completions. */
+    programmaticToolNames?: string[];
+    signal?: AbortSignal;
+    onText?: (delta: string) => void;
+    onThinking?: (delta: string) => void;
+    reasoning?: ReasoningLevel;
+}
+export interface Provider {
+    chat(req: ChatRequest): Promise<Completion>;
+    listModels(): Promise<string[]>;
+}
+export declare class ProviderError extends Error {
+    readonly status?: number | undefined;
+    readonly code?: string | undefined;
+    constructor(message: string, status?: number | undefined, code?: string | undefined);
+}
+interface ProviderOptions {
+    baseURL: string;
+    apiKey?: string;
+    model: string;
+    providerId?: string;
+    fetch?: typeof fetch;
+    retryDelayMs?: number;
+    responsesWebSocketFactory?: (client: OpenAI) => ResponsesWS;
+    /** Experimental Luna-only PTC canary. Kept opt-in until replay/cost canaries pass. */
+    enableProgrammaticToolCalling?: boolean;
+}
+/**
+ * Small models sometimes get stuck emitting the same few characters forever.
+ * Returns where the loop starts when the tail is one short unit (1-12 chars, not just
+ * whitespace) repeated at least 20 times over 300+ chars; otherwise -1. Normal markdown
+ * rules like 80 "=" stay under the length threshold.
+ */
+export declare function detectRepetition(text: string): number;
+/** Plain-text rendering of message content for previews, exports, and the chat UI. */
+export declare function contentText(content: string | ContentPart[]): string;
+/** The user message that carries read images to a vision-capable model. */
+export declare function imageUserMessage(images: ImageAttachment[]): ChatMessage;
+export declare function responseInputFromMessages(messages: ChatMessage[]): Record<string, unknown>[];
+export declare function shouldForceLunaPtc(messages: ChatMessage[], enabled: boolean): boolean;
+/**
+ * Cost-aware PTC gate for Luna.
+ * Beta.24 proved PTC is excellent for large read-heavy aggregation but expensive for one tiny read.
+ * Keep PTC available only when the current turn has multi-source/data-reduction intent, a large
+ * read-only intermediate result, or an already-started program that must be continued safely.
+ */
+export declare function shouldEnableLunaPtc(messages: ChatMessage[], enabled: boolean, programmaticToolNames?: string[]): boolean;
+export interface LunaToolPlan {
+    tools: Record<string, unknown>[];
+    useToolSearch: boolean;
+    useProgrammaticToolCalling: boolean;
+    deferredToolCount: number;
+    deferredSchemaChars: number;
+}
+export declare function lunaToolPlan(tools?: ToolDefinition[], enableProgrammaticToolCalling?: boolean, programmaticToolNames?: string[], forceProgrammaticOnly?: boolean): LunaToolPlan;
+export declare function hasPendingProgrammaticReplay(messages: ChatMessage[]): boolean;
+interface LunaWsContinuation {
+    responseId: string;
+    requestMessages: ChatMessage[];
+    completion: Completion;
+}
+export declare function completionAssistantMessage(completion: Completion): ChatMessage;
+export declare function responseContinuationInput(messages: ChatMessage[], continuation?: LunaWsContinuation): {
+    input: Record<string, unknown>[];
+    previousResponseId?: string;
+    incremental: boolean;
+};
+export declare function createProvider(options: ProviderOptions): Provider;
+export {};

package/dist/{providerCli-FAOZHOKW.js → providerCli-NMUFXAAS.js}

@@ -2,12 +2,12 @@
 import {
   addProviderKey,
   runProviderCommand
-} from "./chunk-JL5ZCSP2.js";
-import "./chunk-XBO5GACQ.js";
-import "./chunk-SPRNLS7K.js";
-import "./chunk-PUN4HMAG.js";
+} from "./chunk-GN4W3T6E.js";
+import "./chunk-75BECX4F.js";
+import "./chunk-JHPGOAXU.js";
+import "./chunk-WNACAUDK.js";
 import "./chunk-BLOYFIAD.js";
-import "./chunk-LACUWBWS.js";
+import "./chunk-FLQPE4S5.js";
 import "./chunk-UZWJQF67.js";
 export {
   addProviderKey,

package/dist/providerCli.d.ts

@@ -0,0 +1,17 @@
+import type { CliArgs } from './args';
+export interface CliDeps {
+    env: NodeJS.ProcessEnv;
+    cwd: string;
+    out: (s: string) => void;
+    err: (s: string) => void;
+    readSecret: (prompt: string) => Promise<string>;
+    fetch?: typeof fetch;
+}
+export declare function addProviderKey(providerId: string, key: string, deps: CliDeps): Promise<{
+    ok: true;
+    models: number;
+} | {
+    ok: false;
+    error: string;
+}>;
+export declare function runProviderCommand(args: CliArgs, deps: CliDeps): Promise<number>;

package/dist/providers.d.ts

@@ -0,0 +1,6 @@
+import { type Config } from './config';
+export declare function providerName(config: Config, id: string): string;
+export declare function hasKey(config: Config, id: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function readGlobalConfigFile(env?: NodeJS.ProcessEnv): Partial<Config>;
+export declare function writeGlobalConfig(patch: Partial<Config>, env?: NodeJS.ProcessEnv): void;
+export declare function removeGlobalProvider(id: string, env?: NodeJS.ProcessEnv): void;

package/dist/reasoning.d.ts

@@ -0,0 +1,12 @@
+export declare const REASONING_LEVELS: readonly ['auto', 'off', 'low', 'medium', 'high', 'max'];
+export type ReasoningLevel = (typeof REASONING_LEVELS)[number];
+export interface ReasoningCapability {
+    levels: readonly ReasoningLevel[];
+    parameter: 'reasoning_effort' | 'reasoning';
+}
+export declare function isReasoningLevel(value: string): value is ReasoningLevel;
+export declare function parseReasoningLevel(value: string, label?: string): ReasoningLevel;
+export declare function reasoningCapability(providerId?: string): ReasoningCapability | undefined;
+export declare function supportedReasoningLevels(providerId?: string): readonly ReasoningLevel[];
+export declare function assertReasoningSupported(providerId: string | undefined, level: ReasoningLevel): void;
+export declare function reasoningPayload(providerId: string | undefined, level: ReasoningLevel): Record<string, unknown>;

package/dist/repomap.d.ts

@@ -0,0 +1,10 @@
+/** Top-level function/class/type names of one file, capped, in source order. */
+export declare function extractSymbols(text: string, ext: string): string[];
+/**
+ * Aider-style repo map: every code file (node_modules/.git excluded) with its top-level
+ * symbols, shallowest paths first, cut off at a token budget. Synchronous on purpose —
+ * it is computed once at boot for the system prompt.
+ */
+export declare function buildRepoMapSync(cwd: string, opts?: {
+    maxTokens?: number;
+}): string;

package/dist/sdk.d.ts

@@ -0,0 +1,57 @@
+import type { Provider } from './provider';
+/**
+ * Programmatic API: run one bccli task in-process. Permissions are allowAll — the caller
+ * is the supervisor. MCP servers are not started; tools are the built-ins + global plugins.
+ */
+export interface SdkOptions {
+    prompt: string;
+    cwd?: string;
+    /** provider/model ref, e.g. "bc-cloud/glm-5.3-flash" (default: the config model). */
+    model?: string;
+    provider?: Provider;
+    env?: NodeJS.ProcessEnv;
+    fetch?: typeof fetch;
+    signal?: AbortSignal;
+}
+export interface SdkToolCall {
+    name: string;
+    target: string;
+    output?: string;
+    isError?: boolean;
+}
+export interface SdkResult {
+    text: string;
+    toolCalls: SdkToolCall[];
+    usage: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    stopReason: 'done' | 'stepLimit' | 'aborted' | 'budgetExceeded';
+}
+export type SdkEvent = {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'thinking';
+    delta: string;
+} | {
+    type: 'toolStart';
+    name: string;
+    target: string;
+} | {
+    type: 'toolEnd';
+    name: string;
+    target: string;
+    output: string;
+    isError?: boolean;
+} | {
+    type: 'usage';
+    inputTokens: number;
+    outputTokens: number;
+} | {
+    type: 'result';
+    result: SdkResult;
+};
+export declare function streamTask(opts: SdkOptions): AsyncGenerator<SdkEvent>;
+/** One-shot helper: runs the task and returns only the final result. */
+export declare function runTask(opts: SdkOptions): Promise<SdkResult>;