@qvac/harness 0.7.1 → 1.0.0-rc.1

package/dist-lib/lib/capabilities/completion-loop/turns.d.ts

@@ -0,0 +1,23 @@
+import type { TrustedSource } from '../../tools/outbound-guard.ts';
+import type { Message, ToolDefinition } from '../types.ts';
+import { type CompletionHistoryEntry } from '../../machine/index.ts';
+export declare function trustedSourcesFrom(history: readonly Message[]): TrustedSource[];
+export declare function sanitizeTurn(turn: Message): Message;
+export declare function lastUserContent(messages: Message[]): string;
+interface TurnImage {
+    path: string;
+}
+export declare function lastUserImages(messages: Message[]): TurnImage[];
+export declare function explicitWebSearchQuery(text: string, tools: ReadonlyArray<ToolDefinition>, { skillPreloaded }: ExplicitWebSearchOptions): string | null;
+interface ExplicitWebSearchOptions {
+    skillPreloaded: boolean;
+}
+export declare function directToolHistory(history: CompletionHistoryEntry[], args: Record<string, unknown>, output: unknown, resultRef?: string): CompletionHistoryEntry[];
+interface AssistantToolCall {
+    name: string;
+    arguments?: Record<string, unknown>;
+}
+export declare function assistantToolTurn(contentText: string, calls: ReadonlyArray<AssistantToolCall>): string;
+export declare function preloadLastUser(messages: readonly CompletionHistoryEntry[], name: string, body: string): CompletionHistoryEntry[];
+export declare function annotateCompletionHistoryLastUserTime(history: readonly CompletionHistoryEntry[], now?: Date): CompletionHistoryEntry[];
+export {};

package/dist-lib/lib/capabilities/completion-loop/turns.js

@@ -0,0 +1,112 @@
+import { stripControlTokens } from '../../helpers/control-tokens.js';
+import { stripToolCallMarkup, toolCallMarkup } from '../../helpers/tool-call-markup.js';
+import { skillPreloadMessage } from '../../tools/skills/mention.js';
+import { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from '../tool-names.js';
+import { DIRECT_CALL_ID, toolResultHistoryEntry, toolResultTurn } from '../tool-turns.js';
+import { annotateLastUserTime } from '../../prompt.js';
+import { isFailureResultReference } from '../../machine/index.js';
+export function trustedSourcesFrom(history) {
+    const sources = [];
+    for (const entry of history) {
+        const text = String(entry.content ?? '');
+        if (entry.role === 'user') {
+            sources.push({ origin: 'user', text });
+        }
+        else if (entry.role === 'tool') {
+            sources.push({ origin: originOfToolTurn(text), text });
+        }
+    }
+    return sources;
+}
+function originOfToolTurn(text) {
+    return text.startsWith(`[Tool: ${SKILL_TOOL_NAME} (`) ? 'skill' : 'tool-result';
+}
+export function sanitizeTurn(turn) {
+    const stripped = stripControlTokens(turn.content);
+    const content = turn.role === 'assistant' ? stripToolCallMarkup(stripped) : stripped;
+    return content === turn.content ? turn : { ...turn, content };
+}
+export function lastUserContent(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const turn = messages[i];
+        if (turn?.role === 'user') {
+            return turn.content;
+        }
+    }
+    return '';
+}
+export function lastUserImages(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const turn = messages[i];
+        if (turn?.role === 'user') {
+            return turn.attachments ?? [];
+        }
+    }
+    return [];
+}
+export function explicitWebSearchQuery(text, tools, { skillPreloaded }) {
+    if (!tools.some((tool) => tool.name === WEB_SEARCH_TOOL_NAME)) {
+        return null;
+    }
+    if (explicitlyDisablesWebSearch(text)) {
+        return null;
+    }
+    const named = /\b(?:search|browse|look\s+up|find)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text);
+    const freshness = /\b(?:latest|current|recent)\s+(?:news|events)\b/i.test(text) ||
+        /\bwhat(?:'s|\s+is)\s+(?:the\s+)?(?:latest|current|recent)\b/i.test(text);
+    const explicit = named || (freshness && !skillPreloaded);
+    return explicit && text.trim() ? text.trim() : null;
+}
+function explicitlyDisablesWebSearch(text) {
+    return (/\b(?:do\s+not|don't|dont|never)\s+(?:search|browse|look\s+up|find|use)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text) ||
+        /\b(?:avoid|without)\s+(?:searching|browsing|using)\s+(?:the\s+)?(?:web|internet|online)\b/i.test(text));
+}
+export function directToolHistory(history, args, output, resultRef) {
+    return [
+        ...history,
+        {
+            role: 'assistant',
+            content: toolCallMarkup([{ name: WEB_SEARCH_TOOL_NAME, arguments: args }])
+        },
+        toolResultHistoryEntry({
+            name: WEB_SEARCH_TOOL_NAME,
+            id: DIRECT_CALL_ID,
+            output,
+            resultRef
+        })
+    ];
+}
+export function assistantToolTurn(contentText, calls) {
+    if (!calls.length || contentText.includes('<function=')) {
+        return contentText;
+    }
+    const markup = toolCallMarkup(calls);
+    return contentText ? `${contentText}\n${markup}` : markup;
+}
+export function preloadLastUser(messages, name, body) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const turn = messages[i];
+        if (!turn || isFailureResultReference(turn)) {
+            continue;
+        }
+        if (turn?.role !== 'user') {
+            continue;
+        }
+        const next = [...messages];
+        next[i] = { ...turn, content: skillPreloadMessage(turn.content, name, body) };
+        return next;
+    }
+    return [...messages];
+}
+export function annotateCompletionHistoryLastUserTime(history, now) {
+    const result = [...history];
+    for (let index = result.length - 1; index >= 0; index--) {
+        const entry = result[index];
+        if (!entry || isFailureResultReference(entry) || entry.role !== 'user') {
+            continue;
+        }
+        result[index] = annotateLastUserTime([entry], now)[0] ?? entry;
+        break;
+    }
+    return result;
+}

package/dist-lib/lib/capabilities/completion-runtime.d.ts

@@ -0,0 +1,46 @@
+import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
+import type { CompletionArgs, CompletionSdk } from './completion.ts';
+import type { CompletionContext } from '../../index.ts';
+import type { CompletionSkillEntry } from './completion-loop/index.ts';
+import { type ModelLoadOptions, type ModelLifecycleSdk, type PoolLike } from '../models/model-pool.ts';
+export type CompletionRuntimeRequest = CompletionContext & {
+    ctxSize?: number;
+};
+interface RuntimeLease {
+    modelId: string;
+    release(): void;
+}
+interface RuntimeAcquireOptions {
+    pool: PoolLike;
+    key: string;
+    open(): ReturnType<PoolLike['open']>;
+    signal?: BareAbortSignal;
+    prepare: () => Promise<boolean>;
+}
+interface RuntimeHarness {
+    _models: PoolLike;
+    _sdk: {
+        load(): Promise<CompletionSdk>;
+    };
+    _unloadIdleGenerators(): Promise<void>;
+    _completionLoadOptions(model: string, agent?: CompletionContext['agent']): ModelLoadOptions;
+    _completionSkills(agentId: string | null, model: string): Promise<CompletionSkillEntry[]>;
+    _acquireModelLease(options: RuntimeAcquireOptions): Promise<RuntimeLease | null>;
+    _makeRoomForCompletion(model: string, options: {
+        ctxSize?: number | undefined;
+        signal?: BareAbortSignal;
+    }): Promise<boolean>;
+    _loadModelLifecycleSdk(): Promise<ModelLifecycleSdk>;
+    suspended: boolean;
+    _runtimeDraining: boolean;
+    _assertNotClosing(): void;
+    _tools: CompletionArgs['tools'];
+}
+interface PreparedRuntime {
+    key: string;
+    args: Partial<CompletionArgs> & {
+        acquireRound: NonNullable<CompletionArgs['acquireRound']>;
+    };
+}
+export declare function prepareCompletionRuntime(harness: RuntimeHarness, request: CompletionRuntimeRequest): Promise<PreparedRuntime>;
+export {};

package/dist-lib/lib/capabilities/completion-runtime.js

@@ -0,0 +1,74 @@
+import { createLocalRoots } from '../tools/fs/local.js';
+import { createRemoteRoots } from '../tools/fs/remote.js';
+import { isResident, modelKey, resolveCtxSize } from '../models/model-pool.js';
+import { hlog } from '../log.js';
+export async function prepareCompletionRuntime(harness, request) {
+    const model = request.model ?? '';
+    const agent = request.agent;
+    const messages = request.messages ?? [];
+    const { signal, grantedDirs, grantedDrives, driveOp } = request;
+    const loadOpts = harness._completionLoadOptions(model, agent);
+    const projectionModel = loadOpts.projectionModel;
+    if (request.resume && request.ctxSize) {
+        loadOpts.ctxSize = request.ctxSize;
+    }
+    const key = modelKey(model, loadOpts);
+    const resident = isResident(harness._models, key);
+    hlog('completion start', { model, resident, projection: Boolean(projectionModel) });
+    const acquireRound = async (invocationSignal) => {
+        const pool = harness._models;
+        const lease = await harness._acquireModelLease({
+            pool,
+            key,
+            open: () => pool.open(key, model, loadOpts),
+            signal: invocationSignal,
+            prepare: async () => {
+                if (!isResident(pool, key)) {
+                    await harness._makeRoomForCompletion(model, {
+                        ctxSize: loadOpts.ctxSize,
+                        signal: invocationSignal ?? signal
+                    });
+                    await harness._unloadIdleGenerators();
+                }
+                return true;
+            }
+        });
+        if (!lease) {
+            throw new Error('A completion round requires a model lease');
+        }
+        try {
+            const sdk = await harness._sdk.load();
+            if (harness.suspended || harness._runtimeDraining) {
+                throw new Error('harness is suspended');
+            }
+            harness._assertNotClosing();
+            return { modelId: lease.modelId, sdk, release: lease.release };
+        }
+        catch (error) {
+            lease.release();
+            throw error;
+        }
+    };
+    const remoteRoots = driveOp && grantedDrives?.length ? createRemoteRoots(grantedDrives, driveOp) : [];
+    return {
+        key,
+        args: {
+            acquireRound,
+            ctxSize: await resolveCtxSize(() => harness._loadModelLifecycleSdk(), model, loadOpts),
+            messages: projectionModel ? messages : messages.map(({ attachments, ...turn }) => turn),
+            requestMessages: messages,
+            tools: harness._tools,
+            skillCatalog: await harness._completionSkills(agent?.id ?? null, model),
+            fsRoots: [
+                ...(grantedDirs?.length ? await createLocalRoots(grantedDirs) : []),
+                ...remoteRoots
+            ],
+            fsWriteRoots: [
+                ...(request.grantedWriteDirs?.length
+                    ? await createLocalRoots(request.grantedWriteDirs)
+                    : []),
+                ...remoteRoots.filter((root) => root.writable)
+            ]
+        }
+    };
+}

package/dist-lib/lib/capabilities/completion.d.ts

@@ -1,335 +1,18 @@
-import type { CompletionFinal, Tool as SdkTool, ToolDialect } from '@qvac/sdk';
-import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import { type TextEvent } from '../helpers/thinking.ts';
-import type { ToolCallDisplay } from '../tool-call-display.ts';
-import { type LlmGenerationParams } from '../models/llm-presets.ts';
-import type { DriveRoot } from '../tools/fs/scope.ts';
-import { type UsageBreakdown } from './usage-breakdown.ts';
-import { type TrustedSource } from '../tools/outbound-guard.ts';
-import type { SkillCatalogEntry } from '../tools/skills/catalog.ts';
-import { type SkillState } from '../tools/skills/skill-state-constants.ts';
-import type { CliValidator } from '../tools/skills/cli-schema.ts';
-import { type Toolset } from '../tools/toolsets.ts';
-export interface MessageAttachment {
-    path: string;
-}
-export interface Message {
-    role: string;
-    content: string;
-    attachments?: MessageAttachment[];
-    [key: string]: unknown;
-}
-export interface Agent {
-    id?: string;
-    name?: string;
-    bio?: string;
-    enabledTools?: string[] | null;
-    enabledSkills?: string[] | null;
-    toolsScope?: 'all' | 'selected' | null;
-    skillsScope?: 'all' | 'selected' | null;
-    reasoning?: 'inherit' | 'enabled' | 'disabled' | null;
-    ctxSize?: number | null;
-    kvCacheK?: string | null;
-    kvCacheV?: string | null;
-    imageModelChoice?: string | null;
-    imageSteps?: number | null;
-    imageWidth?: number | null;
-    imageHeight?: number | null;
-    approvalMode?: 'ask' | 'skip-all' | null;
-    disabledToolsets?: string[] | null;
-    sandboxMode?: boolean | null;
-}
-export interface ImageSettings {
-    modelChoice?: string;
-    steps?: number;
-    width?: number;
-    height?: number;
-}
-export declare function imageSettingsFrom(agent?: Agent): ImageSettings | undefined;
-export interface MusicSettings {
-    modelChoice?: string;
-    steps?: number;
-    duration?: number;
-}
-export interface ResourceDescriptor {
-    kind: string;
-    label: string;
-}
-export type ToolEffect = 'read' | 'write';
-export type ApproveFn = (call: {
-    name: string;
-    arguments: Record<string, unknown>;
-    resource?: ResourceDescriptor | null;
-    effect?: ToolEffect;
-    intent?: string | null;
-    display?: ToolCallDisplay | null;
-}) => Promise<boolean>;
-export type ToolDecision = 'auto' | 'allowed' | 'denied' | 'skip-all' | 'blocked';
-export type ToolActivityFn = (entry: ToolActivityEvent) => void;
-export interface AttachInput {
-    fileName: string;
-    mimeType: string;
-    bytes: Uint8Array;
-    raw?: boolean;
-}
-export interface AttachmentRecord {
-    id: string;
-    fileName: string;
-    mimeType: string;
-    byteLength: number;
-}
-export type AttachFn = (input: AttachInput) => Promise<AttachmentRecord>;
-export interface AttachmentMeta {
-    id: string;
-    fileName: string;
-    mimeType: string;
-    byteLength: number;
-}
-export interface FetchedAttachment extends AttachmentMeta {
-    bytes: Uint8Array;
-}
-export type FetchAttachmentFn = (query: {
-    attachmentId?: string;
-    signal?: BareAbortSignal;
-    meta?: boolean;
-}) => Promise<FetchedAttachment | AttachmentMeta | null>;
-export type ProgressFn = (update: {
-    percentage: number;
-} | null) => void;
-export type RagSearchFn = (input: {
-    query: string;
-    limit?: number;
-}) => Promise<RagSearchResult>;
-export interface RagSearchResult {
-    enabled: boolean;
-    indexEmpty: boolean;
-    hasKnowledge: boolean;
-    pendingReferenced?: boolean;
-    errorMessage?: string | null;
-    hits: ReadonlyArray<{
-        content: string;
-        metadataJson?: string | null;
-        score: number;
-    }>;
-}
-export type AskUserFn = (question: {
-    question: string;
-    options?: string[];
-}) => Promise<string | null>;
-export interface RunBudget {
-    readonly deadlineMs: number;
-    outputBytesUsed: number;
-}
-export interface ToolExecuteContext {
-    agentId?: string | null | undefined;
-    skills?: readonly string[] | undefined;
-    ctxSize?: number | undefined;
-    image?: ImageSettings | undefined;
-    settings?: Record<string, unknown> | undefined;
-    turnImages?: {
-        path: string;
-    }[] | undefined;
-    attach?: AttachFn | undefined;
-    fetchAttachment?: FetchAttachmentFn | undefined;
-    ragSearch?: RagSearchFn | undefined;
-    progress?: ProgressFn | undefined;
-    askUser?: AskUserFn | undefined;
-    signal?: BareAbortSignal | undefined;
-    fsRoots?: readonly DriveRoot[] | undefined;
-    fsWriteRoots?: readonly DriveRoot[] | undefined;
-    toolOps?: ReadonlyMap<string, readonly CliValidator[]> | undefined;
-    runBudget?: RunBudget | undefined;
-    reportBackend?: ((use: RunBackendUse) => void) | undefined;
-    uncappedResponse?: boolean | undefined;
-    sandboxMode?: boolean | undefined;
-    toolNames?: readonly string[] | undefined;
-    approval?: ToolDecision | undefined;
-}
-export interface RunBackendUse {
-    tool: string;
-    requestedGpu: boolean;
-    device: 'gpu' | 'cpu' | 'unknown';
-    backend: string;
-}
-export type ToolParameterType = 'string' | 'number' | 'boolean' | 'object' | 'integer' | 'array' | 'null';
-export interface ToolParameterSchema {
-    type: ToolParameterType | readonly ToolParameterType[];
-    description?: string;
-    enum?: string[];
-    items?: ToolParameterSchema;
-    properties?: Record<string, ToolParameterSchema>;
-    required?: string[];
-}
-export interface ToolParameters {
-    type: 'object';
-    properties: Record<string, ToolParameterSchema>;
-    required?: string[];
-}
-export interface ToolPromptDefinition {
-    description?: string;
-    parameters?: ToolParameters;
-}
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    parameters: ToolParameters;
-    prompt?: ToolPromptDefinition;
-    autoApprove?: boolean;
-    skillGated?: boolean;
-    rootsRequired?: boolean;
-    writeRootsRequired?: boolean;
-    externalWrite?: boolean;
-    owningSkill?: string;
-    toolset: Toolset | null;
-    validate?: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => string | null;
-    effect: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => ToolEffect;
-    resource?: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => ResourceDescriptor | null;
-    compiled?: true;
-    execute: (args: Record<string, unknown>, ctx?: ToolExecuteContext) => Promise<unknown>;
-}
-export interface ToolCallEvent {
-    type: 'tool-call';
-    name: string;
-    args: Record<string, unknown>;
-    rawCall?: string | undefined;
-    effect?: ToolEffect | undefined;
-    display?: ToolCallDisplay | undefined;
-}
-export interface ToolResultEvent {
-    type: 'tool-result';
-    name: string;
-    result: unknown;
-}
-export interface ToolActivityEvent {
-    type: 'tool-activity';
-    name: string;
-    args: Record<string, unknown>;
-    resource: ResourceDescriptor | null;
-    effect: ToolEffect;
-    decision: ToolDecision;
-}
-export interface ErrorEvent {
-    type: 'error';
-    message: string;
-}
-export interface AbortedEvent {
-    type: 'aborted';
-}
-export interface MetricsEvent {
-    type: 'metrics';
-    totalTokens: number;
-    durationMs: number;
-    timeToFirstToken?: number | undefined;
-    tokensPerSecond?: number | undefined;
-    promptTokensPerSecond?: number | undefined;
-    promptTokens?: number | undefined;
-    cacheTokens?: number | undefined;
-    ctxSize?: number | undefined;
-    backends?: RunBackendUse[] | undefined;
-    usage?: UsageBreakdown | undefined;
-    route?: 'direct' | 'enhanced' | undefined;
-    routeModel?: string | undefined;
-    stopReason?: string | undefined;
-}
-export interface InferenceCall {
-    round: number;
-    droppedTurns: number;
-    modelId: string;
-    messages: Message[];
-    tools: SdkTool[] | undefined;
-    generationParams: LlmGenerationParams | undefined;
-    responseFormat: ResponseFormat | undefined;
-    toolDialect: ToolDialect | undefined;
-    cacheKey: string | undefined;
-    promptPrefix: string;
-}
-export interface InferenceCallEvent {
-    type: 'inference-call';
-    call: InferenceCall;
-}
-export interface InferenceSentEvent {
-    type: 'inference-sent';
-    round: number;
-    droppedTurns: number;
-    messages: Message[] | undefined;
-    tokens: InferenceTokens | undefined;
-    outcome: 'completed' | 'overflowed' | 'failed';
-    reason: string | undefined;
-}
-export interface InferenceTokens {
-    prompt?: number | undefined;
-    generated?: number | undefined;
-    cached?: number | undefined;
-    timeToFirstToken?: number | undefined;
-}
-export type CompletionEvent = TextEvent | ToolCallEvent | ToolResultEvent | ToolActivityEvent | ErrorEvent | AbortedEvent | MetricsEvent | InferenceCallEvent | InferenceSentEvent;
-export interface CompletionSdkResult {
-    requestId?: string;
-    tokenStream: AsyncIterable<string>;
-    final: Promise<CompletionFinal>;
-}
-export type ResponseFormat = {
-    type: 'text';
-} | {
-    type: 'json_object';
-} | {
-    type: 'json_schema';
-    json_schema: {
-        name: string;
-        description?: string;
-        schema: Record<string, unknown>;
-        strict?: boolean;
-    };
-};
-export interface CompletionSdk {
-    completion(params: {
-        modelId: string;
-        history: Message[];
-        stream: true;
-        tools?: SdkTool[] | undefined;
-        generationParams?: LlmGenerationParams | undefined;
-        responseFormat?: ResponseFormat | undefined;
-        toolDialect?: ToolDialect | undefined;
-        kvCache?: string | boolean;
-    }): CompletionSdkResult;
-    cancel?(params: {
-        requestId: string;
-    }): Promise<void>;
-}
-export interface RoundModelLease {
-    modelId: string;
-    release: () => void;
-}
-interface CompletionArgs {
-    modelId: string;
-    acquireRound?: () => Promise<RoundModelLease>;
-    model?: string;
-    agent?: Agent;
-    ctxSize?: number;
-    cacheKey?: string;
-    thinkingDefault?: string;
-    generationParams?: LlmGenerationParams;
-    responseFormat?: ResponseFormat;
-    messages: Message[];
-    tools?: ToolDefinition[];
-    skillCatalog?: readonly CompletionSkillEntry[];
-    approve?: ApproveFn;
-    attach?: AttachFn;
-    fetchAttachment?: FetchAttachmentFn;
-    ragSearch?: RagSearchFn;
-    progress?: ProgressFn;
-    askUser?: AskUserFn;
-    signal?: BareAbortSignal;
-    toolConfigs?: Record<string, Record<string, unknown>>;
-    fsRoots?: readonly DriveRoot[];
-    fsWriteRoots?: readonly DriveRoot[];
-    captureInferenceCalls?: boolean;
-}
-export declare const CONTEXT_OVERFLOW_MESSAGE = "This message is too large for the model context window.";
-export declare function trustedSourcesFrom(history: readonly Message[]): TrustedSource[];
-export declare function toSdkTool(tool: ToolDefinition): SdkTool;
-export type CompletionSkillEntry = SkillCatalogEntry & {
-    readonly status?: SkillState;
-};
-export declare function completion(sdk: CompletionSdk, { modelId, acquireRound, model, agent, ctxSize, cacheKey, thinkingDefault, generationParams: generationParamsOverride, responseFormat, messages: storedMessages, tools: allTools, skillCatalog, approve, attach, fetchAttachment, ragSearch, progress, askUser, signal, toolConfigs, fsRoots, fsWriteRoots, captureInferenceCalls }: CompletionArgs): AsyncGenerator<CompletionEvent>;
-export {};
+import { type CompletionRun, type CompletionRuntime } from './completion-engine/driver.ts';
+import type { EngineBoot, EngineStep } from '../machine/index.ts';
+import type { CompletionArgs } from './completion-loop/index.ts';
+import type { CompletionSdk } from './types.ts';
+export * from './types.ts';
+export type { CompletionRun };
+export type { CompletionArgs } from './completion-loop/index.ts';
+interface CompletionRunOptions {
+    boot?: EngineBoot;
+    onStep?: (step: EngineStep) => Promise<void>;
+    hostAppendTimeoutMs?: number;
+    onDetached?: (pending: Promise<void>, runId?: string) => void;
+    requestDigestKey?: Uint8Array;
+    resumeRequest?: Partial<CompletionArgs>;
+    bootRequest?: unknown;
+}
+export { CONTEXT_OVERFLOW_MESSAGE, imageSettingsFrom, loadedSkillsFrom, skillInContext, skillLoadedTurn, toSdkTool, trustedSourcesFrom, unreadySkillState, type CompletionSkillEntry } from './completion-loop/index.ts';
+export declare function completion(sdk: CompletionSdk | CompletionRuntime, args: CompletionArgs, options?: CompletionRunOptions): CompletionRun;