@botconnector/bccli 0.4.0 → 0.4.2

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-6FWQABJ7.js → oauthLogin-XWY7OHCG.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/oauthLogin.ts
 import { createHash, randomBytes } from "crypto";

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-ZQNKWZHJ.js}

@@ -2,10 +2,10 @@
 import {
   bccliHome,
   globalConfigPath
-} from "./chunk-LACUWBWS.js";
+} from "./chunk-RX4UQX43.js";
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/pluginsCli.ts
 import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";

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-5IMV3VNQ.js → prCli-6PUWTMTP.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   t
-} from "./chunk-UZWJQF67.js";
+} from "./chunk-3WHI4LN3.js";
 
 // src/prCli.ts
 import { spawn } from "child_process";
@@ -21,7 +21,15 @@ function defaultGh(argv) {
   });
 }
 function prTaskArgv(entry, opts) {
-  return [entry, ...opts.prompt ? ["-p", opts.prompt] : [], ...opts.allowAll ? ["--allow-all"] : []];
+  return [
+    entry,
+    ...opts.prompt ? ["-p", opts.prompt] : [],
+    ...opts.model ? ["-m", opts.model] : [],
+    ...opts.reasoning ? ["--reasoning", opts.reasoning] : [],
+    ...opts.permissionMode ? ["--permission-mode", opts.permissionMode] : [],
+    ...opts.allowedTools?.length ? ["--allowed-tools", opts.allowedTools.join(",")] : [],
+    ...opts.allowAll ? ["--allow-all"] : []
+  ];
 }
 async function defaultRunTask(opts) {
   const entry = process.argv[1];
@@ -38,7 +46,7 @@ async function defaultRunTask(opts) {
 }
 async function runPrCommand(args, deps) {
   const rest = [...args.subArgs];
-  let repo;
+  let repo = args.repo;
   const words = [];
   for (let i = 0; i < rest.length; i++) {
     if (rest[i] === "--repo") {
@@ -70,7 +78,15 @@ async function runPrCommand(args, deps) {
   const runTask = deps.runTask ?? defaultRunTask;
   const allowAll = args.allowAll === true;
   if (allowAll) deps.err?.(t("--allow-all: the PR task runs every tool without asking"));
-  return runTask({ prompt: task, allowAll, cwd: args.cwd });
+  return runTask({
+    prompt: task,
+    allowAll,
+    cwd: args.cwd,
+    ...args.model ? { model: args.model } : {},
+    ...args.reasoning ? { reasoning: args.reasoning } : {},
+    ...args.permissionMode ? { permissionMode: args.permissionMode } : {},
+    ...args.allowedTools?.length ? { allowedTools: args.allowedTools } : {}
+  });
 }
 export {
   prTaskArgv,

package/dist/prCli.d.ts

@@ -0,0 +1,46 @@
+export interface PrCliArgs {
+    subArgs: string[];
+    cwd: string;
+    /** Set only when the user asked for `bccli pr … --allow-all`. */
+    allowAll?: boolean;
+    repo?: string;
+    model?: string;
+    reasoning?: string;
+    permissionMode?: string;
+    allowedTools?: string[];
+}
+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;
+        model?: string;
+        reasoning?: string;
+        permissionMode?: string;
+        allowedTools?: 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;
+    model?: string;
+    reasoning?: string;
+    permissionMode?: string;
+    allowedTools?: string[];
+}): 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,16 @@
+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';
+/** Combines an optional piped stdin payload with the `-p` prompt argument. */
+export declare function resolvePrintPrompt(prompt: string | undefined, stdinText: string | undefined): string | undefined;
+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,145 @@
+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;
+/**
+ * Wraps a primary provider with automatic fallback providers tried in order when the primary
+ * fails before emitting any text (e.g. HTTP 429 rate-limit/quota, 5xx, or connection failure).
+ */
+export declare function withFallbackProvider(primary: Provider, fallbacks: () => Provider[]): Provider;
+export {};

package/dist/providerCli-5OZI2GQQ.js

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import {
+  addProviderKey,
+  runProviderCommand
+} from "./chunk-H7XJDKJY.js";
+import "./chunk-IYR5PYA3.js";
+import "./chunk-HQW4BROS.js";
+import "./chunk-5YJ3ZQVR.js";
+import "./chunk-KPTML72Q.js";
+import "./chunk-RX4UQX43.js";
+import "./chunk-3WHI4LN3.js";
+export {
+  addProviderKey,
+  runProviderCommand
+};

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,61 @@
+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' | 'error';
+    error?: string;
+}
+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: 'error';
+    message: string;
+} | {
+    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>;