@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/worker/harness-sidecar.mjs

@@ -4,30 +4,27 @@ import FileLog from 'bare-file-logger'
 import fs from 'fs'
 import { dirname, join } from 'path'
 import process from 'bare-process'
+import { sealAddons } from '#addon-seal'
 import { configureSdkStorage } from '../dist-lib/lib/sdk-storage.js'
 import {
   Harness,
   loadSkillCatalog,
+  musicModelSet,
   serveHarness,
   setHarnessLog,
   setHarnessLogSink
 } from '../dist-lib/index.js'
-import { createCreateDocumentsTool } from '../dist-lib/lib/tools/create-documents.js'
-import { createEditDocumentsTool } from '../dist-lib/lib/tools/edit-documents.js'
-import { createExecTool } from '../dist-lib/lib/tools/exec.js'
-import { createFileGlobTool } from '../dist-lib/lib/tools/file-glob.js'
-import { deniedRootsFor } from '../dist-lib/lib/tools/fs/scope.js'
-import { createGrepTool } from '../dist-lib/lib/tools/grep.js'
-import { createHttpRequestTool } from '../dist-lib/lib/tools/http-request.js'
-import { createMcpCallTool } from '../dist-lib/lib/tools/mcp-call.js'
-import { compileOperationTools } from '../dist-lib/lib/tools/operations/compile.js'
-import { createReadFilesTool } from '../dist-lib/lib/tools/read-files.js'
-import { createSkillTool } from '../dist-lib/lib/tools/skill.js'
-import { ensureBundledSkillsDir } from '../dist-lib/lib/tools/skills/bundled-dir.js'
-import { credentialAllowListFor, mcpReadMethods } from '../dist-lib/lib/tools/skills/index.js'
-import { createWeatherLookupTool } from '../dist-lib/lib/tools/weather-lookup.js'
-import { createWebFetchTool } from '../dist-lib/lib/tools/web-fetch.js'
-import { createWebSearchTool } from '../dist-lib/lib/tools/web-search.js'
+import { Tools } from '../dist-lib/lib/tools/index.js'
+import { Image } from '../dist-lib/plugins/image/index.js'
+import { Knowledge } from '../dist-lib/plugins/knowledge/index.js'
+import { McpPlugin } from '../dist-lib/plugins/mcp/index.js'
+import { Music } from '../dist-lib/plugins/music/index.js'
+import { ObsidianRoute } from '../dist-lib/plugins/obsidian/index.js'
+import { Python } from '../dist-lib/plugins/python/index.js'
+import { Speech } from '../dist-lib/plugins/speech/index.js'
+import { TranslationPlugin } from '../dist-lib/plugins/translation/index.js'
+import { Weather } from '../dist-lib/plugins/weather/index.js'
+import { WebSearchPlugin } from '../dist-lib/plugins/web-search/index.js'
 
 // at maxSize rotate to a single overwritten archive, as the assistant's Logger does
 const LOG_MAX_SIZE = 100_000_000
@@ -78,7 +75,6 @@ export default async function start(ipc, ready) {
   Bare.IPC.on('end', die).on('close', die)
 
   const sdkStorage = JSON.parse(Bare.argv[3] || '{}')
-  const deniedRoots = deniedRootsFor(sdkStorage.home)
   const hostWantsLogs = Bare.argv[7] === '1'
   setHarnessLog(hostWantsLogs)
   // before the first await so nothing logs ahead of the sink; the host writes assistant.log beside it
@@ -87,7 +83,7 @@ export default async function start(ipc, ready) {
   captureConsole(log)
   await alignSdkConsoleWithHost(hostWantsLogs)
 
-  const skillsDir = Bare.argv[2] || (await ensureBundledSkillsDir())
+  const skillsDir = Bare.argv[2] || (await Tools.bundledSkillsDir())
   const embedConfig = JSON.parse(Bare.argv[4] || '{}')
   const imageModel = Bare.argv[5] ? JSON.parse(Bare.argv[5]) : undefined
   const imageClamps = Bare.argv[6] ? JSON.parse(Bare.argv[6]) : undefined
@@ -95,6 +91,8 @@ export default async function start(ipc, ready) {
   const musicModel = Bare.argv[9] ? JSON.parse(Bare.argv[9]) : undefined
   const musicClamps = Bare.argv[10] ? JSON.parse(Bare.argv[10]) : undefined
   const gpuStats = Bare.argv[12] ? JSON.parse(Bare.argv[12]) : undefined
+  const knowledge = Bare.argv[13] ? JSON.parse(Bare.argv[13]) : undefined
+  const pluginOptions = Bare.argv[14] ? JSON.parse(Bare.argv[14]) : {}
   // Only the host knows where the shipped wheels landed.
   if (Bare.argv[11]) {
     process.env.QVAC_PYTHON_WHEELS_DIR = Bare.argv[11]
@@ -104,58 +102,65 @@ export default async function start(ipc, ready) {
   process.env.QVAC_PYODIDE_CACHE_DIR = `${sdkStorage.home}/pyodide-cache`
 
   const skillCatalog = skillsDir ? await loadSkillCatalog(skillsDir) : undefined
-  const credentialed = skillCatalog
-    ? {
-        credentialStore: (key, ctx) => harness?.resolveCredential(key, ctx) ?? null,
-        credentialAllowList: credentialAllowListFor(skillCatalog)
-      }
+  const credentialStore = skillCatalog
+    ? (key, ctx) => harness?.resolveCredential(key, ctx) ?? null
     : undefined
-
-  const httpRequestTool = createHttpRequestTool(credentialed)
-  const mcpCallTool = createMcpCallTool({
-    ...credentialed,
-    readMethods: skillCatalog ? mcpReadMethods(skillCatalog) : undefined
+  const tools = Tools.product({
+    sdkHome: sdkStorage.home,
+    skillsDir,
+    skillCatalog,
+    credentialStore
   })
-  const tools = [
-    httpRequestTool,
-    createExecTool({
-      ...credentialed,
-      deniedRoots,
-      skillsDir,
-      skillSettings: (skill, agentId) => harness?.skillSettings(skill, agentId) ?? {}
-    }),
-    mcpCallTool,
-    createWebSearchTool(),
-    createWebFetchTool(),
-    createWeatherLookupTool(),
-    createReadFilesTool({ deniedRoots }),
-    createFileGlobTool({ deniedRoots }),
-    createGrepTool({ deniedRoots }),
-    createCreateDocumentsTool({ deniedRoots }),
-    createEditDocumentsTool({ deniedRoots })
+
+  const plugins = [
+    new Python(),
+    new ObsidianRoute({ credentialStore }),
+    new Speech(pluginOptions.speech),
+    new TranslationPlugin(),
+    new Weather({ read: ['weather_lookup'] }),
+    new WebSearchPlugin({ read: ['web_search'] }),
+    // granted read so a skill's declared read methods on its server do not ask
+    new McpPlugin({
+      generic: true,
+      servers: pluginOptions.mcp?.servers,
+      skillCatalog,
+      credentialStore,
+      read: ['mcp_call']
+    })
   ]
-  if (skillCatalog) {
-    tools.push(...compileOperationTools(skillCatalog, { httpRequestTool, mcpCallTool }))
+  if (imageModel) {
+    // granted read so a generation does not ask for approval; edit_image stays a write
+    plugins.push(new Image({ model: imageModel, clamps: imageClamps, read: ['generate_image'] }))
   }
 
-  if (skillsDir) {
-    tools.push(
-      createSkillTool({
-        skillsDir,
-        credentialStore: credentialed?.credentialStore
-      })
-    )
+  // a stale choice string resolves to nothing and leaves music out
+  const music = typeof musicModel === 'string' ? musicModelSet(musicModel) : musicModel
+  if (music) {
+    plugins.push(new Music({ model: music, clamps: musicClamps, read: ['generate_music'] }))
   }
 
+  if (knowledge) {
+    plugins.push(new Knowledge({ dir: knowledge.dir, model: knowledge.model }))
+  }
+
+  // host options arrive as untyped JSON: a plugin they do not fit is left out, never the harness
+  const valid = plugins.filter((plugin) => {
+    const reason = invalid(plugin)
+    if (reason) {
+      log.error(SCOPE, `plugin '${plugin.name}' left out: ${reason}`)
+    }
+
+    return !reason
+  })
+
   harness = new Harness({
     gpuStats,
     tools,
+    // exec is built here from the plugins' python language and obsidian route
+    exec: true,
     skillsDir,
+    sdkHome: sdkStorage.home,
     modelsDir: sdkStorage.models,
-    imageModel,
-    imageClamps,
-    musicModel,
-    musicClamps,
     embedDevice: embedConfig.device,
     embedGpuLayers: embedConfig.gpuLayers,
     embedBatchSize: embedConfig.batchSize,
@@ -164,12 +169,28 @@ export default async function start(ipc, ready) {
     contextSize: llmConfig.contextSize,
     kvCacheK: llmConfig.kvCacheK,
     kvCacheV: llmConfig.kvCacheV,
-    completionModelCap: llmConfig.completionModelCap
+    llmLoad: llmConfig.llmLoad,
+    slots: llmConfig.slots,
+    completionModelCap: llmConfig.completionModelCap,
+    plugins: valid
   })
+  // ready() loads every addon the harness and its plugins declare; a failure is each call's error
+  await harness.ready().catch((err) => log.error(SCOPE, 'harness failed to open', err))
+  // nothing served can load a new native addon, a .bare a run wrote to disk included
+  sealAddons()
   serveHarness(ipc, harness)
   ready()
 
   return () => {}
 }
 
+// a wrong shape makes validate() throw rather than return its reason
+function invalid(plugin) {
+  try {
+    return plugin.validate?.() ?? null
+  } catch (err) {
+    return err.message
+  }
+}
+
 function noop() {}

package/dist-lib/lib/capabilities/completion-engine/actors/inspect-preload.d.ts

@@ -1,3 +0,0 @@
-import { type PreloadInspectionOutput } from '../../../machine/index.ts';
-import type { CompletionActor } from '../session.ts';
-export declare const inspectPreload: CompletionActor<PreloadInspectionOutput>;

package/dist-lib/lib/capabilities/completion-engine/actors/inspect-preload.js

@@ -1,75 +0,0 @@
-import { AbortedError } from '../../../helpers/race-abort.js';
-import { copy, toolDeniedResult } from '../../../machine/index.js';
-import { inspectToolPolicy } from '../../completion-loop/index.js';
-import { SKILL_TOOL_NAME } from '../../tool-names.js';
-import { toolContext, trustedSources } from './execution-plan.js';
-import { preloadFailure } from './preload-failure.js';
-export const inspectPreload = async function inspectPreload({ input: deps, context }) {
-    const { args, session } = deps;
-    const pending = context.skillPreload;
-    if (!pending) {
-        throw new Error('preload inspection requires a pending skill');
-    }
-    const loader = session.enabled.find((tool) => tool.name === SKILL_TOOL_NAME);
-    if (!loader) {
-        throw new Error('skill preload requires the skill tool');
-    }
-    if (args.signal?.aborted) {
-        throw new AbortedError();
-    }
-    const loaderArgs = { name: pending.name };
-    const callId = `preload-${pending.name}`;
-    const executeContext = toolContext({ deps, context, name: loader.name });
-    const fold = await session.pipeline.runPreToolFold({
-        runId: session.runId,
-        callId,
-        toolName: loader.name,
-        agentId: args.agent?.id ?? null,
-        args: loaderArgs,
-        skillNames: session.inContextSkills.map((skill) => skill.name),
-        parameters: loader.parameters,
-        sandboxMode: args.agent?.sandboxMode === true,
-        signal: args.signal
-    });
-    if (args.signal?.aborted) {
-        throw new AbortedError();
-    }
-    if (!fold.ok) {
-        return {
-            name: pending.name,
-            args: loaderArgs,
-            facts: null,
-            hookRejection: fold.rejection,
-            failure: preloadFailure({
-                history: context.history,
-                startedAt: session.startedAt,
-                name: pending.name,
-                error: fold.rejection.error
-            })
-        };
-    }
-    const facts = inspectToolPolicy(loader, fold.args, executeContext, {
-        ...trustedSources(deps, context),
-        denied: new Set(context.deniedKeys),
-        key: session.callKey(loader.name, fold.args),
-        skipApprovals: false
-    });
-    const failureReason = facts.validationError ??
-        facts.refusal ??
-        (facts.deniedKey ? toolDeniedResult().error : null) ??
-        (facts.effect !== 'read' ? 'Skill loading requires a read-only tool.' : null);
-    return {
-        name: pending.name,
-        args: copy(fold.args),
-        facts,
-        hookRejection: null,
-        failure: failureReason
-            ? preloadFailure({
-                history: context.history,
-                startedAt: session.startedAt,
-                name: pending.name,
-                error: failureReason
-            })
-            : null
-    };
-};

package/dist-lib/lib/capabilities/completion-engine/actors/preload-failure.d.ts

@@ -1,9 +0,0 @@
-import { type CompletionMachineContext } from '../../../machine/index.ts';
-import type { SkillFailedPayload } from '../../../machine/index.ts';
-export interface PreloadFailureInput {
-    history: CompletionMachineContext['history'];
-    startedAt: number;
-    name: string;
-    error: string;
-}
-export declare function preloadFailure({ history, startedAt, name, error }: PreloadFailureInput): SkillFailedPayload;

package/dist-lib/lib/capabilities/completion-engine/actors/preload-failure.js

@@ -1,11 +0,0 @@
-import { spliceFrom } from '../../../machine/index.js';
-import { annotateCompletionHistoryLastUserTime, preloadLastUser } from '../../completion-loop/index.js';
-export function preloadFailure({ history, startedAt, name, error }) {
-    const message = `Skill "${name}" could not be loaded: ${error}`;
-    const guided = preloadLastUser(history, name, message);
-    return {
-        name,
-        error: message,
-        history: spliceFrom(history, annotateCompletionHistoryLastUserTime(guided, new Date(startedAt)))
-    };
-}

package/dist-lib/lib/capabilities/completion-engine/actors/preloading.d.ts

@@ -1,3 +0,0 @@
-import { type SkillLoadOutput } from '../../../machine/index.ts';
-import type { CompletionActor } from '../session.ts';
-export declare const preloading: CompletionActor<SkillLoadOutput>;

package/dist-lib/lib/capabilities/completion-engine/actors/preloading.js

@@ -1,114 +0,0 @@
-import { AbortedError } from '../../../helpers/race-abort.js';
-import { RecoveryRequired, ToolPolicyChanged, spliceFrom } from '../../../machine/index.js';
-import { executeCall, annotateCompletionHistoryLastUserTime, labelOf, preloadLastUser, readyPreflightFromFacts, skillEmojiFrom } from '../../completion-loop/index.js';
-import { withoutSkillLoadTurns } from '../../tool-turns.js';
-import { SKILL_TOOL_NAME } from '../../tool-names.js';
-import { trustedSourceFacts } from '../../../tools/outbound-guard.js';
-import { errorMessage, isRecord } from '../../../guards.js';
-import { toolContext } from './execution-plan.js';
-import { preloadFailure } from './preload-failure.js';
-import { detachJson } from '../../../helpers/detach-json.js';
-export const preloading = async function preloading({ emit, input: deps, context }) {
-    const { args, session } = deps;
-    const pending = context.skillPreload;
-    if (!pending) {
-        throw new Error('preload execution requires an authorized skill');
-    }
-    const loader = session.enabled.find((tool) => tool.name === SKILL_TOOL_NAME);
-    if (!loader) {
-        throw new Error('skill preload requires the skill tool');
-    }
-    if (!pending.args || !pending.facts) {
-        throw new Error('skill preload has no authorized facts');
-    }
-    if (args.signal?.aborted) {
-        throw new AbortedError();
-    }
-    const preloadArgs = pending.args;
-    const contextForLoader = toolContext({ deps, context, name: loader.name });
-    const currentEffect = loader.effect(detachJson(preloadArgs), contextForLoader);
-    if (currentEffect !== pending.facts.effect || currentEffect !== 'read') {
-        return failure({
-            context,
-            startedAt: session.startedAt,
-            name: pending.name,
-            error: 'Skill loading is no longer classified as a read-only operation.'
-        });
-    }
-    const display = labelOf(SKILL_TOOL_NAME, preloadArgs, skillEmojiFrom(session.inContextSkills, pending.name));
-    const callId = `preload-${pending.name}`;
-    let activity = null;
-    let result;
-    try {
-        const executed = await executeCall(loader, preloadArgs, contextForLoader, {
-            runId: session.runId,
-            signal: args.signal,
-            sources: [],
-            pipeline: session.pipeline,
-            callId,
-            effect: currentEffect,
-            preflight: readyPreflightFromFacts(pending.facts),
-            display,
-            onToolActivity: (event) => (activity = event)
-        });
-        result = executed.result;
-    }
-    catch (error) {
-        if (error instanceof RecoveryRequired || error instanceof ToolPolicyChanged) {
-            throw error;
-        }
-        if (error instanceof AbortedError || args.signal?.aborted) {
-            throw new AbortedError();
-        }
-        const message = errorMessage(error);
-        return failure({ context, startedAt: session.startedAt, name: pending.name, error: message });
-    }
-    if (args.signal?.aborted) {
-        throw new AbortedError();
-    }
-    if (!context.skills.snapshot?.loaded.includes(pending.name)) {
-        emit({
-            type: 'tool-call',
-            name: SKILL_TOOL_NAME,
-            args: preloadArgs,
-            effect: 'read',
-            display
-        });
-        if (activity) {
-            emit(activity);
-        }
-        emit({ type: 'tool-result', name: SKILL_TOOL_NAME, result });
-    }
-    if (!hasContent(result)) {
-        return failure({
-            context,
-            startedAt: session.startedAt,
-            name: pending.name,
-            error: errorFrom(result) ?? 'skill did not return content'
-        });
-    }
-    const content = String(result.content);
-    session.loadedThisTurn.add(pending.name);
-    session.skillIcon = skillEmojiFrom(session.inContextSkills, pending.name) ?? session.skillIcon;
-    const inlined = preloadLastUser(context.history, pending.name, content);
-    const turns = withoutSkillLoadTurns(inlined, pending.name);
-    const history = annotateCompletionHistoryLastUserTime(turns, new Date(session.startedAt));
-    return {
-        name: pending.name,
-        history: spliceFrom(context.history, history),
-        source: trustedSourceFacts('skill', content),
-        cacheable: false
-    };
-};
-function failure({ context, startedAt, name, error }) {
-    return { failure: preloadFailure({ history: context.history, startedAt, name, error }) };
-}
-function hasContent(value) {
-    return isRecord(value) && 'content' in value;
-}
-function errorFrom(value) {
-    if (isRecord(value) && 'error' in value) {
-        return errorMessage(value.error);
-    }
-    return null;
-}

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

@@ -1,80 +0,0 @@
-import type { Tool as SdkTool } from '@qvac/sdk';
-import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-import type { LlmGenerationParams } from '../../models/llm-presets.ts';
-import type { DriveRoot } from '../../tools/fs/scope.ts';
-import type { SkillCatalogEntry } from '../../tools/skills/catalog.ts';
-import type { RecoveryResolution } from '../../machine/index.ts';
-import { type SkillState } from '../../tools/skills/skill-state-constants.ts';
-import { enabledTools } from '../tool-selection.ts';
-import type { ToolCallDisplay } from '../../tool-call-display.ts';
-import type { Agent, CompletionEvent, ApproveFn, AskUserFn, AttachFn, FetchAttachmentFn, ImageSettings, Message, ProgressFn, RagSearchFn, ResponseFormat, RunBudget, RoundModelLease, ToolDefinition, ToolExecuteContext } from '../types.ts';
-export { isSelected, skillsAreSelected } from '../tool-selection.ts';
-export { enabledTools };
-export { loadedSkillsFrom, skillLoadedTurn } from '../tool-turns.ts';
-export { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from '../tool-names.ts';
-export { foldMetrics, metricsEvent, type MetricsState } from './metrics.ts';
-export { CONTEXT_OVERFLOW_MESSAGE, runRecoveredRound, type RecoveredRound, type RoundArgs } from './round.ts';
-export { callSucceeded, executeCall, MAX_BLOCKED_REPEATS, settledFailure, toolCallKey, inspectToolPolicy, readyPreflightFromFacts, preflightToolCall, resolveToolCalls, type ResolvedCall, type ToolPreflight } from './tool-execution.ts';
-export { assistantToolTurn, annotateCompletionHistoryLastUserTime, directToolHistory, explicitWebSearchQuery, lastUserContent, lastUserImages, preloadLastUser, sanitizeTurn, trustedSourcesFrom } from './turns.ts';
-export declare function imageSettingsFrom(agent?: Agent): ImageSettings | undefined;
-export interface CompletionArgs {
-    runId?: string;
-    resume?: boolean;
-    recovery?: RecoveryResolution[];
-    lockOwner?: object;
-    modelId: string;
-    acquireRound?: (signal?: BareAbortSignal) => Promise<RoundModelLease>;
-    model?: string;
-    agent?: Agent;
-    ctxSize?: number;
-    cacheKey?: string;
-    thinkingDefault?: string;
-    generationParams?: LlmGenerationParams;
-    responseFormat?: ResponseFormat;
-    messages: Message[];
-    requestMessages?: 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 { MAX_CAPPED_ROUNDS, MAX_MUTE_ROUNDS, MAX_TOOL_ROUNDS } from '../../machine/index.ts';
-export declare const MAX_WEB_SEARCHES_PER_TURN = 3;
-export declare const WEB_SEARCH_LIMIT_MESSAGE: string;
-export declare function toSdkTool(tool: ToolDefinition): SdkTool;
-export declare function labelOf(name: string, args: Record<string, unknown>, emoji: string | null): ToolCallDisplay;
-export declare function skillEmojiFrom(catalog: readonly CompletionSkillEntry[], name: string): string | null;
-export type CompletionSkillEntry = SkillCatalogEntry & {
-    readonly status?: SkillState;
-};
-export declare function skillInContext(entry: CompletionSkillEntry): boolean;
-export declare function unreadySkillState(name: string, catalog: readonly CompletionSkillEntry[]): SkillState | null;
-export declare function reportUnnamedWrites(said: string, landed: ReadonlyArray<string>): Generator<CompletionEvent>;
-export declare function reportLandedWrites(landed: ReadonlyArray<string>): Generator<CompletionEvent>;
-export declare function createRunBudget(startedAt: number): RunBudget;
-export type ToolContextFactory = (turnImages?: {
-    path: string;
-}[], ctxSize?: number, signal?: BareAbortSignal) => ToolExecuteContext;
-export declare function runToolContext(args: Pick<CompletionArgs, 'agent' | 'attach' | 'fetchAttachment' | 'ragSearch' | 'progress' | 'askUser' | 'signal' | 'fsRoots' | 'fsWriteRoots'>, runBudget: RunBudget): ToolContextFactory;
-export interface ToolSelectionInputs {
-    responseFormat: boolean;
-    tools: readonly ToolDefinition[];
-    toolsSelected: boolean;
-    allowlist: ReadonlyArray<string>;
-    activeSkills: readonly CompletionSkillEntry[];
-    loadedSkills: ReadonlySet<string>;
-    grantedNames: ReadonlySet<string>;
-    grantedOwners: ReadonlyMap<string, ReadonlySet<string>>;
-    hasRoots: boolean;
-    hasWriteRoots: boolean;
-}
-export declare function selectEnabledTools(inputs: ToolSelectionInputs): ToolDefinition[];

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

@@ -1,158 +0,0 @@
-import process from 'process';
-import { isAvailableState } from '../../tools/skills/skill-state-constants.js';
-import { unnamedWrites, writeReport } from '../../helpers/run-outcome.js';
-import { INTENT_PARAM, INTENT_PARAM_DESCRIPTION } from '../../helpers/tool-intent.js';
-import { fallbackToolLabel } from '../../helpers/tool-label.js';
-import { collectToolGrants, enabledTools } from '../tool-selection.js';
-export { isSelected, skillsAreSelected } from '../tool-selection.js';
-export { enabledTools };
-export { loadedSkillsFrom, skillLoadedTurn } from '../tool-turns.js';
-export { SKILL_TOOL_NAME, WEB_SEARCH_TOOL_NAME } from '../tool-names.js';
-export { foldMetrics, metricsEvent } from './metrics.js';
-export { CONTEXT_OVERFLOW_MESSAGE, runRecoveredRound } from './round.js';
-export { callSucceeded, executeCall, MAX_BLOCKED_REPEATS, settledFailure, toolCallKey, inspectToolPolicy, readyPreflightFromFacts, preflightToolCall, resolveToolCalls } from './tool-execution.js';
-export { assistantToolTurn, annotateCompletionHistoryLastUserTime, directToolHistory, explicitWebSearchQuery, lastUserContent, lastUserImages, preloadLastUser, sanitizeTurn, trustedSourcesFrom } from './turns.js';
-export function imageSettingsFrom(agent) {
-    if (!agent) {
-        return undefined;
-    }
-    const settings = {};
-    if (agent.imageModelChoice) {
-        settings.modelChoice = agent.imageModelChoice;
-    }
-    if (agent.imageSteps) {
-        settings.steps = agent.imageSteps;
-    }
-    if (agent.imageWidth) {
-        settings.width = agent.imageWidth;
-    }
-    if (agent.imageHeight) {
-        settings.height = agent.imageHeight;
-    }
-    return Object.keys(settings).length ? settings : undefined;
-}
-export { MAX_CAPPED_ROUNDS, MAX_MUTE_ROUNDS, MAX_TOOL_ROUNDS } from '../../machine/index.js';
-export const MAX_WEB_SEARCHES_PER_TURN = 3;
-export const WEB_SEARCH_LIMIT_MESSAGE = 'Web search limit reached for this question. Answer now from the results already gathered. ' +
-    'If something was not found, say so plainly and mention the most relevant sources. ' +
-    'Do not call web_search again.';
-function intentParameters(tool, params) {
-    if (tool.autoApprove === true || INTENT_PARAM in params.properties) {
-        return params;
-    }
-    return {
-        ...params,
-        properties: {
-            [INTENT_PARAM]: { type: 'string', description: INTENT_PARAM_DESCRIPTION },
-            ...params.properties
-        },
-        required: [INTENT_PARAM, ...(params.required ?? [])]
-    };
-}
-function sdkParameterSchema(schema) {
-    const { sensitive: _sensitive, properties, items, ...rest } = schema;
-    return {
-        ...rest,
-        properties: properties
-            ? Object.fromEntries(Object.entries(properties).map(([key, value]) => [key, sdkParameterSchema(value)]))
-            : undefined,
-        items: items ? sdkParameterSchema(items) : undefined
-    };
-}
-function sdkParameters(parameters) {
-    return {
-        ...parameters,
-        properties: Object.fromEntries(Object.entries(parameters.properties).map(([key, value]) => [key, sdkParameterSchema(value)]))
-    };
-}
-export function toSdkTool(tool) {
-    return {
-        type: 'function',
-        name: tool.name,
-        description: tool.prompt?.description ?? tool.description,
-        parameters: sdkParameters(intentParameters(tool, tool.prompt?.parameters ?? tool.parameters))
-    };
-}
-export function labelOf(name, args, emoji) {
-    const display = { label: fallbackToolLabel(name, args) };
-    return emoji ? { ...display, iconEmoji: emoji } : display;
-}
-export function skillEmojiFrom(catalog, name) {
-    return catalog.find((entry) => entry.name === name)?.emoji ?? null;
-}
-export function skillInContext(entry) {
-    return entry.status === undefined || isAvailableState(entry.status);
-}
-export function unreadySkillState(name, catalog) {
-    const status = catalog.find((entry) => entry.name === name)?.status;
-    return status !== undefined && !isAvailableState(status) ? status : null;
-}
-export function* reportUnnamedWrites(said, landed) {
-    const unreported = writeReport(unnamedWrites(said, landed));
-    if (unreported) {
-        yield { type: 'content', text: unreported };
-    }
-}
-export function* reportLandedWrites(landed) {
-    const written = writeReport(landed);
-    if (written) {
-        yield { type: 'content', text: written };
-    }
-}
-const RUN_WALL_CLOCK_BUDGET_MS = 30 * 60_000;
-export function createRunBudget(startedAt) {
-    const override = Number(process.env.QVAC_RUN_BUDGET_MS);
-    const duration = Number.isFinite(override) && override > 0 ? override : RUN_WALL_CLOCK_BUDGET_MS;
-    return { deadlineMs: startedAt + duration, outputBytesUsed: 0 };
-}
-export function runToolContext(args, runBudget) {
-    const { agent, attach, fetchAttachment, ragSearch, progress, askUser, signal } = args;
-    const image = imageSettingsFrom(agent);
-    return (turnImages = [], ctxSize, invocationSignal) => {
-        const context = {
-            agentId: agent?.id ?? null,
-            ctxSize,
-            fsRoots: args.fsRoots ?? [],
-            fsWriteRoots: args.fsWriteRoots ?? [],
-            runBudget,
-            signal: invocationSignal ?? signal
-        };
-        if (image) {
-            context.image = image;
-        }
-        if (turnImages.length) {
-            context.turnImages = turnImages;
-        }
-        if (attach) {
-            context.attach = attach;
-        }
-        if (fetchAttachment) {
-            context.fetchAttachment = fetchAttachment;
-        }
-        if (ragSearch) {
-            context.ragSearch = ragSearch;
-        }
-        if (progress) {
-            context.progress = progress;
-        }
-        if (askUser) {
-            context.askUser = askUser;
-        }
-        return context;
-    };
-}
-export function selectEnabledTools(inputs) {
-    if (inputs.responseFormat)
-        return [];
-    const loaded = inputs.activeSkills.filter((skill) => inputs.loadedSkills.has(skill.name));
-    return enabledTools(inputs.tools, {
-        toolsSelected: inputs.toolsSelected,
-        allowlist: inputs.allowlist,
-        grantedNames: inputs.grantedNames,
-        grantedOwners: inputs.grantedOwners,
-        loadedGrantedNames: collectToolGrants(loaded).grantedNames,
-        hasRoots: inputs.hasRoots,
-        hasWriteRoots: inputs.hasWriteRoots,
-        hasActiveSkills: inputs.activeSkills.length > 0
-    });
-}