@qoder-ai/qoder-agent-sdk 1.0.4 → 1.0.6

package/dist/core/runtime-launch-options.d.ts

@@ -0,0 +1,84 @@
+import type { DiagnosticsSink } from './sdk-diagnostics.js';
+import type { SdkPluginConfig, ToolConfig } from '../types/common.js';
+import type { InternalAuthOptions } from '../types/auth.js';
+import type { PermissionMode } from '../types/permissions.js';
+import type { McpServerConfigForProcessTransport, McpServerToolPolicy } from '../types/mcp.js';
+import type { SettingSource } from '../types/options.js';
+export declare class AuthAccessTokenEnvVarError extends Error {
+    readonly code: "auth_access_token_env_var_not_configured";
+    constructor(envVar: string);
+}
+type ToolsOption = string[] | {
+    type: 'preset';
+    preset: 'qodercli';
+};
+export interface RuntimeLaunchOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    proxy?: string;
+    auth?: InternalAuthOptions;
+    model?: string;
+    debug?: boolean;
+    agent?: string;
+    sessionId?: string;
+    continue?: boolean;
+    resume?: string;
+    forkSession?: boolean;
+    maxTurns?: number;
+    permissionMode?: PermissionMode;
+    allowDangerouslySkipPermissions?: boolean;
+    permissionPromptToolName?: string;
+    canUseTool?: boolean;
+    includePartialMessages?: boolean;
+    includeHookEvents?: boolean;
+    allowedTools?: string[];
+    disallowedTools?: string[];
+    tools?: ToolsOption;
+    toolConfig?: ToolConfig;
+    extensions?: string[];
+    mcpServers?: Record<string, McpServerConfigForProcessTransport>;
+    mcpToolPolicies?: Record<string, McpServerToolPolicy[]>;
+    allowedMcpServerNames?: string[];
+    strictMcpConfig?: boolean;
+    settings?: string | Record<string, unknown>;
+    settingSources?: SettingSource[];
+    additionalDirectories?: string[];
+    plugins?: SdkPluginConfig[];
+    enableFileCheckpointing?: boolean;
+    extraArgs?: Record<string, string | null>;
+}
+export interface RuntimeLaunchConfig {
+    args: string[];
+    env: Record<string, string>;
+    authPayloadPath?: string;
+}
+export declare function isScriptFile(filePath: string): boolean;
+export declare function resolveDefaultCliPath(): string;
+export declare class RuntimeLaunchOptionsBuilder {
+    private readonly options;
+    private readonly diagnostics?;
+    private readonly logPrefix;
+    private authPayloadPath;
+    private generatedSettingsDir;
+    constructor(options: RuntimeLaunchOptions, diagnostics?: DiagnosticsSink, logPrefix?: string);
+    prepare(): Promise<RuntimeLaunchConfig>;
+    cleanupGeneratedSettings(): void;
+    cleanupAuthPayload(): Promise<void>;
+    buildEnv(): Record<string, string>;
+    buildArgs(): string[];
+    private buildSettingsArg;
+    private applyFileCheckpointingSetting;
+    private applySettingsCompatibility;
+    private toQoderDefaultPermissionMode;
+    private applyAdditionalDirectories;
+    private buildCliMcpServers;
+    private collectMcpPolicyPermissionRules;
+    private hasMcpPolicyRules;
+    private applyMcpPolicyRules;
+    private readSettingsFile;
+    private writeGeneratedSettingsFile;
+    private createAuthPayloadFile;
+    private buildAuthPayload;
+    private resolveAccessToken;
+}
+export {};

package/dist/core/transport.d.ts

@@ -11,6 +11,10 @@
  */
 import type { StdoutMessage } from '../types/control.js';
 export interface Transport {
+    /**
+     * Start the underlying runtime and make the transport ready.
+     */
+    initialize(): Promise<void>;
     /**
      * Write a JSON line to the CLI process stdin.
      * The transport is responsible for appending the newline delimiter.
@@ -44,4 +48,15 @@ export interface Transport {
      * entire transport — the CLI may still produce output.
      */
     endInput(): void;
+}
+/**
+ * Provider for creating a fresh transport for each query() session.
+ *
+ * A transport instance is stateful: it owns stdin/stdout readers, close state,
+ * auth payload cleanup, and runtime lifetime. Host integrations should pass a
+ * provider rather than a reusable Transport instance so every query gets an
+ * isolated connection.
+ */
+export interface QueryTransportProvider<TOptions = any> {
+    create(options: TOptions): Transport;
 }

package/dist/core/worker-transport.d.ts

@@ -0,0 +1,86 @@
+/**
+ * WorkerTransport — runs qoder-worker-runtime inside a Node worker thread.
+ *
+ * This transport keeps the existing SDK stream-json protocol but replaces the
+ * child-process boundary with worker stdin/stdout/stderr streams. It is meant
+ * for hosts that already own a Node runtime, including Node SEA hosts, and want
+ * to avoid spawning a second qoder SEA process.
+ */
+import type { QueryTransportProvider, Transport } from './transport.js';
+import type { ProcessTransportOptions } from './process-transport.js';
+import type { StdoutMessage } from '../types/control.js';
+import type { DiagnosticsSink } from './sdk-diagnostics.js';
+import { type RuntimeLaunchOptions } from './runtime-launch-options.js';
+export declare class QoderWorkerRuntimeError extends Error {
+    readonly code: "QODER_WORKER_RUNTIME_ERROR";
+    readonly exitCode?: number;
+    readonly stderr?: string;
+    constructor(message: string, options?: {
+        exitCode?: number;
+        stderr?: string;
+        cause?: unknown;
+    });
+}
+export interface WorkerTransportOptions {
+    /** Path to qoder-worker-runtime.obf.mjs or an equivalent worker entry. */
+    pathToQoderWorkerRuntime?: string;
+    /** Extra Node worker execArgv. Defaults to an empty list to avoid host flags leaking. */
+    execArgv?: string[];
+    /** Additional workerData merged under the top-level object. */
+    workerData?: Record<string, unknown>;
+}
+export interface WorkerRuntimeTransportOptions extends RuntimeLaunchOptions, WorkerTransportOptions {
+    /** stderr handling mode */
+    stderr?: 'inherit' | 'pipe' | 'ignore';
+    /** Optional callback for worker stderr output */
+    stderrHandler?: (data: string) => void;
+    /** Abort controller */
+    abortController?: AbortController;
+    /** SDK-internal diagnostics sink. */
+    diagnostics?: DiagnosticsSink;
+    /** Called once when the worker exits with an auth-related status. */
+    onAuthExpired?: () => void;
+}
+export declare class WorkerTransport implements QueryTransportProvider<ProcessTransportOptions> {
+    static readonly default: WorkerTransport;
+    private readonly options;
+    constructor(options?: WorkerTransportOptions);
+    create(options: ProcessTransportOptions): Transport;
+}
+export declare class WorkerRuntimeTransport implements Transport {
+    private worker;
+    private options;
+    private ready;
+    private closed;
+    private initializePromise;
+    private authExpiredFired;
+    private pendingInput;
+    private diagnostics?;
+    private workerExitError;
+    private stderrTail;
+    private observedExitCode;
+    private launchOptionsBuilder;
+    private closeTimer;
+    constructor(options?: WorkerRuntimeTransportOptions);
+    initialize(): Promise<void>;
+    private _doInitialize;
+    write(data: string): void;
+    isReady(): boolean;
+    endInput(): void;
+    readMessages(): AsyncGenerator<StdoutMessage, void, unknown>;
+    close(): void;
+    get threadId(): number | undefined;
+    private writeReadyLine;
+    private flushPendingInput;
+    private endReadyInput;
+    private appendStderr;
+    private createWorkerError;
+    private createWorkerExitError;
+    private getStderrTail;
+    private waitForWorkerExit;
+    private clearCloseTimer;
+    private cleanupAuthPayload;
+    private fireAuthExpired;
+}
+export declare function resolveQoderWorkerRuntimePath(explicitPath?: string): string;
+export declare function hasResolvableQoderWorkerRuntime(explicitPath?: string): boolean;

package/dist/direct-connect/direct-connect-transport.d.ts

@@ -19,8 +19,10 @@ export declare class DirectConnectTransport implements Transport {
     private messages;
     private exitError?;
     private partialLine;
+    private initializePromise;
     constructor(options: DirectConnectOptions);
-    private initialize;
+    initialize(): Promise<void>;
+    private doInitialize;
     write(data: string): Promise<void>;
     close(): void;
     isReady(): boolean;

package/dist/global/plugins.d.ts

@@ -0,0 +1,14 @@
+import type { PluginDetails } from '../types/plugins.js';
+export declare function listPlugins(opts?: {
+    orgId?: string;
+    cliPath?: string;
+    env?: Record<string, string>;
+}): Promise<PluginDetails[]>;
+export declare function enablePlugin(id: string, opts?: {
+    cliPath?: string;
+    env?: Record<string, string>;
+}): Promise<void>;
+export declare function disablePlugin(id: string, opts?: {
+    cliPath?: string;
+    env?: Record<string, string>;
+}): Promise<void>;

package/dist/index.d.ts

@@ -3,8 +3,8 @@
  *
  * TypeScript SDK for programmatic access to qodercli capabilities.
  *
- * The SDK works by spawning a qodercli subprocess and communicating
- * via a bidirectional JSON line protocol over stdin/stdout.
+ * The SDK talks to the configured Qoder runtime transport using a
+ * bidirectional JSON line protocol.
  *
  * @example Basic usage
  * ```typescript
@@ -52,7 +52,9 @@
  * ```
  */
 export { query } from './query/query.js';
-export { QoderCliProcessError } from './core/process-transport.js';
+export { DEFAULT_RUNTIME_TRANSPORT, } from './core/default-runtime.js';
+export { ProcessTransport, QoderCliProcessError, } from './core/process-transport.js';
+export { hasResolvableQoderWorkerRuntime, QoderWorkerRuntimeError, WorkerTransport, resolveQoderWorkerRuntimePath, } from './core/worker-transport.js';
 export { DEFAULT_ACCESS_TOKEN_ENV_VAR, accessToken, accessTokenFromEnv, jobToken, qodercliAuth, } from './auth.js';
 export { createSdkMcpServer, tool } from './mcp/sdk-mcp-server.js';
 export type { AnyZodRawShape, InferShape, SdkMcpToolDefinition, ToolExtras, CreateSdkMcpServerOptions, } from './mcp/sdk-mcp-server.js';
@@ -60,6 +62,8 @@ export type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 export type { ToolAnnotations } from '@modelcontextprotocol/sdk/types.js';
 export { listSessions, getSessionInfo, getSessionMessages, getSubagentMessages, listSubagents, renameSession, tagSession, } from './session/session-manager.js';
 export { forkSession } from './session/session-fork.js';
+export { listPlugins, enablePlugin, disablePlugin } from './global/plugins.js';
+export type { PluginDetails, PluginResources } from './types/plugins.js';
 export { submitFeedback } from './feedback.js';
 export type { SubmitFeedbackParams, SubmitFeedbackOptions, IntegrationMode, } from './feedback.js';
 export { AbortError, DirectConnectError, ModelPolicyTimeoutError, ProtocolVersionMismatchError, } from './core/errors.js';
@@ -74,9 +78,14 @@ export type { AccessTokenInput, AuthOptions } from './types/auth.js';
  * @internal Internal auth types for first-party host integration, not general public use.
  */
 export type { FetchJobToken, JobTokenAuthOptions, JobTokenRequest, JobTokenResult, } from './types/auth.js';
-export type { AccountInfo, UsageAddOnQuotaBucket, UsageInfo, UsageOrgResourcePackage, UsageQuotaBucket, ApiKeySource, ExitReason, FastModeState, ConfigScope, SettingSource, SDKAssistantMessageError, SDKStatus, EffortLevel, ThinkingAdaptive, ThinkingEnabled, ThinkingDisabled, ThinkingConfig, OutputFormatType, JsonSchemaOutputFormat, OutputFormat, BaseOutputFormat, ModelInfo, ModelSource, ModelStrategy, ModelContextConfig, ModelContextWindowEntry, ModelEffortEntry, ModelThinkingConfig, ModelThinkingDisabled, ModelThinkingEnabled, ModelUsage, NonNullableUsage, SlashCommand, ToolConfig, SdkPluginConfig, } from './types/common.js';
+export type { AccountInfo, UsageAddOnQuotaBucket, UsageInfo, UsageOrgResourcePackage, UsageQuotaBucket, ApiKeySource, ExitReason, FastModeState, ConfigScope, SettingSource, SDKAssistantMessageError, SDKStatus, EffortLevel, ThinkingAdaptive, ThinkingEnabled, ThinkingDisabled, ThinkingConfig, OutputFormatType, JsonSchemaOutputFormat, OutputFormat, BaseOutputFormat, ModelInfo, ModelSource, ServerModelJson, ServerModelJsonValue, ModelStrategy, ModelPromotion, LocalizedModelText, ModelContextConfig, ModelContextWindowEntry, ModelEffortEntry, ModelThinkingConfig, ModelThinkingDisabled, ModelThinkingEnabled, ModelUsage, NonNullableUsage, SlashCommand, ToolConfig, SdkPluginConfig, } from './types/common.js';
 export type { SDKMessage, SDKAssistantMessage, SDKUserMessage, SDKUserMessageReplay, SDKResultMessage, SDKResultSuccess, SDKResultError, SDKSystemMessage, SDKSystemInitMessage, SDKSystemMessageSubtype, SDKSystemMessageBySubtype, SDKPartialAssistantMessage, SDKCompactBoundaryMessage, SDKStatusMessage, SDKAPIRetryMessage, SDKLocalCommandOutputMessage, SDKHookStartedMessage, SDKHookProgressMessage, SDKHookResponseMessage, SDKPermissionDeniedMessage, SDKTaskNotificationMessage, SDKTaskStartedMessage, SDKTaskProgressMessage, SDKSessionStateChangedMessage, SDKSessionTitleChangedMessage, SDKBridgeStateMessage, SDKFilesPersistedEvent, SDKElicitationCompleteMessage, SDKPromptSuggestionMessage, SDKCloudAgentEventMessage, SDKPermissionDenial, } from './types/messages.js';
-export type { Options, Query, SpawnOptions, SpawnedProcess, ElicitationRequest, ElicitationResult, OnElicitation, PromptRequest, PromptRequestOption, PromptResponse, CanUseTool, Transport, } from './types/options.js';
+export type { DefaultRuntimeTransport, } from './core/default-runtime.js';
+export type { QueryTransportCreateOptions, QueryTransportProviderOption, } from './core/query-transport.js';
+export type { ProcessTransportOptions } from './core/process-transport.js';
+export type { WorkerRuntimeTransportOptions, WorkerTransportOptions, } from './core/worker-transport.js';
+export type { QueryTransportProvider, Transport, } from './core/transport.js';
+export type { Options, QueryTransportOptions, Query, SpawnOptions, SpawnedProcess, ElicitationRequest, ElicitationResult, OnElicitation, PromptRequest, PromptRequestOption, PromptResponse, CanUseTool, } from './types/options.js';
 export type { AgentCreateParams, BetaManagedAgentsAgentToolName, BetaManagedAgentsAgentToolset20260401Params, BetaManagedAgentsCustomSkillParams, BetaManagedAgentsFileResourceParams, BetaManagedAgentsModel, BetaManagedAgentsSkillParams, BetaManagedAgentsURLMCPServerParams, CloudAgentOptions, CloudAgentReference, CloudAgentStreamOptions, CloudSessionResource, CloudSessionCreateParams, CloudSessionCreateReference, CloudSessionExistingReference, CloudSessionReference, SessionCreateParams, } from './types/cloud-agent.js';
 export type { SettingSource as SettingSourceFromOptions } from './types/options.js';
 export type { PermissionMode, PermissionBehavior, PermissionDecisionClassification, PermissionUpdateDestination, PermissionRuleValue, PermissionUpdate, PermissionResult, CanUseToolOptions, PermissionDecisionReasonType, ExitPlanModeApprovalDetails, } from './types/permissions.js';