subconscious-cli 6.0.1 → 6.2.0

package/bin/model-capabilities.js

@@ -1,14 +1,15 @@
-import { readFileSync } from 'node:fs';
-
-// The models endpoint currently supplies IDs, not modality metadata. Keep
-// explicit capabilities in the same registry used to generate the Unix lookup.
-const { modelCapabilities = {} } = JSON.parse(
-  readFileSync(new URL('./registry.generated.json', import.meta.url), 'utf8'),
-);
+import { MODEL_CAPABILITIES } from './agent-data.js';
 
+// The models endpoint supplies IDs, not modality metadata, so capabilities
+// are listed by exact model ID: similarly named models inherit nothing.
 export function modelSupportsVision(modelId) {
   return (
-    Object.hasOwn(modelCapabilities, modelId) &&
-    modelCapabilities[modelId].vision === true
+    Object.hasOwn(MODEL_CAPABILITIES, modelId) &&
+    MODEL_CAPABILITIES[modelId].vision === true
   );
 }
+
+/** Vision model IDs, newline-separated, for the runbooks' shell lookup. */
+export function visionModelList() {
+  return Object.keys(MODEL_CAPABILITIES).filter(modelSupportsVision).join('\n');
+}

package/bin/models.js

@@ -106,26 +106,26 @@ export async function fetchGatewayModels({
       };
       controller.signal.addEventListener('abort', fail, { once: true });
     });
-    const response = await Promise.race([
-      fetchImpl(endpoint, {
+    const discover = async () => {
+      const response = await fetchImpl(endpoint, {
         method: 'GET',
         headers,
         cache: 'no-store',
         signal: controller.signal,
-      }),
-      aborted,
-    ]);
+      });
 
-    if (!response.ok) {
-      throw new Error(`Model discovery returned HTTP ${response.status}`);
-    }
+      if (!response.ok) {
+        throw new Error(`Model discovery returned HTTP ${response.status}`);
+      }
 
-    const payload = await response.json();
-    if (!Array.isArray(payload?.data)) {
-      throw new Error('Model discovery returned an invalid response');
-    }
+      const payload = await response.json();
+      if (!Array.isArray(payload?.data)) {
+        throw new Error('Model discovery returned an invalid response');
+      }
 
-    return normalizeModelIds(payload.data.map((model) => model?.id));
+      return normalizeModelIds(payload.data.map((model) => model?.id));
+    };
+    return await Promise.race([discover(), aborted]);
   } catch (error) {
     if (signal?.aborted) throw abortError('Model discovery was cancelled');
     if (controller.signal.aborted) {
@@ -175,10 +175,22 @@ export async function resolveModelCatalog({
   apiKey,
   selectedModel,
   fallbackModels = [],
+  pinnedModels,
   fetchImpl = globalThis.fetch,
   timeoutMs = DEFAULT_MODEL_FETCH_TIMEOUT_MS,
   signal,
 }) {
+  // A caller that names its catalog (a benchmark run, a CI job) needs the same
+  // models on every launch, whatever the gateway lists that day.
+  const pinned = pinnedModels?.split(/\r?\n/).filter((id) => id.trim());
+  if (pinned?.length) {
+    return {
+      models: normalizeModelIds(pinned, selectedModel),
+      source: 'pinned',
+      error: null,
+    };
+  }
+
   const key = apiKey?.trim() || '';
 
   if (key) {

package/bin/opencode-provider.js

@@ -1,6 +1,11 @@
+import { fileURLToPath } from 'node:url';
+import { modelIds, positiveInteger } from './launch-values.js';
 import { modelSupportsVision } from './model-capabilities.js';
 
 export const OPENCODE_PROVIDER_ID = 'subconscious';
+const OPENCODE_IMAGE_WINDOW_PLUGIN = fileURLToPath(
+  new URL('./runbook/opencode/subconscious-image-window.ts', import.meta.url),
+);
 export const OPENCODE_PROVIDER_NAME = 'Subconscious Gateway';
 
 const ACRONYMS = new Set([
@@ -64,6 +69,8 @@ export function buildOpenCodeConfig({
   return {
     $schema: 'https://opencode.ai/config.json',
     disabled_providers: ['subconscious-cli'],
+    // Trims each request to the newest 30 images before upload.
+    plugin: [OPENCODE_IMAGE_WINDOW_PLUGIN],
     provider: {
       [OPENCODE_PROVIDER_ID]: {
         npm: '@ai-sdk/openai-compatible',
@@ -81,3 +88,17 @@ export function buildOpenCodeConfig({
     model: `${OPENCODE_PROVIDER_ID}/${model}`,
   };
 }
+
+/** The launch config for the env subc passes to OpenCode. */
+export function openCodeConfigFromEnv(env) {
+  return buildOpenCodeConfig({
+    baseUrl: String(env.GATEWAY_URL ?? '').replace(/\/+$/, ''),
+    model: env.MODEL,
+    modelIds: modelIds(env),
+    context: positiveInteger(
+      env.OPENCODE_CONTEXT_LIMIT,
+      'OPENCODE_CONTEXT_LIMIT',
+    ),
+    output: positiveInteger(env.OPENCODE_OUTPUT_LIMIT, 'OPENCODE_OUTPUT_LIMIT'),
+  });
+}

package/bin/profile-settings.js

@@ -0,0 +1,129 @@
+import {
+  AGENTS,
+  agentInputs,
+  DEFAULTS,
+  PACKAGED_MODELS,
+  resolveRefs,
+  SHARED_INPUTS,
+  staticLookup,
+} from './agent-data.js';
+
+export const SUPPORTED_MODELS = Object.freeze([...PACKAGED_MODELS]);
+
+const TOKEN = /\{[A-Za-z][A-Za-z0-9]*\}/;
+const shown = (input) => input.label && input.group !== 'shared';
+
+function toSetting(input) {
+  const model = input.type === 'model';
+  const setting = {
+    key: input.name,
+    label: input.label,
+    description: input.description,
+    type: model ? 'choice' : input.type || 'text',
+  };
+  if (model) Object.assign(setting, { choices: SUPPORTED_MODELS, model });
+  if (input.choices) setting.choices = input.choices;
+  for (const field of ['min', 'max', 'required'])
+    if (input[field] !== undefined) setting[field] = input[field];
+  return Object.freeze(setting);
+}
+
+function group(id, label, inputs) {
+  return Object.freeze({
+    id,
+    label,
+    keys: inputs.map((input) => input.name),
+    settings: inputs.map(toSetting),
+  });
+}
+
+export const PROFILE_SETTING_GROUPS = Object.freeze([
+  group(
+    'shared',
+    'Shared settings',
+    SHARED_INPUTS.filter((input) => input.group === 'shared'),
+  ),
+  ...AGENTS.map((agent) =>
+    group(agent.id, agent.name, agentInputs(agent).filter(shown)),
+  ),
+]);
+
+/** A default a profile can hold: literal, with references resolved. */
+function profileDefault(input, lookup) {
+  if (input.type === 'secret' || input.default === undefined) return '';
+  const value = String(resolveRefs(input.default, lookup));
+  return TOKEN.test(value) ? '' : value;
+}
+
+function agentDefaults(agent) {
+  const lookup = staticLookup(agent);
+  // A profile pins every default it holds, so inputs kept out of the
+  // template stay out of new and existing profiles.
+  return agentInputs(agent)
+    .filter((input) => input.label && input.template !== false)
+    .map((input) => [input.name, profileDefault(input, lookup)]);
+}
+
+export const RUNBOOK_DEFAULTS = Object.freeze({
+  ...Object.fromEntries(AGENTS.flatMap(agentDefaults)),
+  GATEWAY_URL: DEFAULTS.baseUrl,
+  API_KEY: '',
+  MODEL: DEFAULTS.model,
+});
+
+export function profileSettingsForAgent(agentId) {
+  const shared = PROFILE_SETTING_GROUPS.find((item) => item.id === 'shared');
+  const agent = PROFILE_SETTING_GROUPS.find((item) => item.id === agentId);
+  return [...(shared?.settings || []), ...(agent?.settings || [])];
+}
+
+export function resolvedProfileValues(profile) {
+  return { ...RUNBOOK_DEFAULTS, ...(profile?.values || {}) };
+}
+
+function templateLine(input) {
+  const line = `${input.name}={${input.name}}`;
+  return input.comment ? [`# ${input.comment}`, line] : [line];
+}
+
+function agentSections() {
+  const written = new Set();
+  return AGENTS.flatMap((agent) => {
+    const inputs = agentInputs(agent).filter(
+      (input) =>
+        shown(input) &&
+        input.type !== 'secret' &&
+        input.template !== false &&
+        !written.has(input.name),
+    );
+    for (const input of inputs) written.add(input.name);
+    if (!inputs.length) return [];
+    return ['', `# ${agent.name}`, ...inputs.flatMap(templateLine)];
+  });
+}
+
+/** The new-profile file, with `{KEY}` where each value goes. */
+export function profileTemplate() {
+  const keys = AGENTS.flatMap((agent) =>
+    agentInputs(agent).filter(
+      (input) => shown(input) && input.type === 'secret',
+    ),
+  );
+  return [
+    '# Subconscious coding-agent profile',
+    '# Generated by subc. Extra KEY=value lines are passed through to launches.',
+    '',
+    'GATEWAY_URL={GATEWAY_URL}',
+    'API_KEY={API_KEY}',
+    '# Available models (MODEL=UNSET uses the first live catalog model):',
+    ...SUPPORTED_MODELS.map((model) => `#   ${model}`),
+    'MODEL={MODEL}',
+    '',
+    '# Optional per-agent keys. Leave blank to use API_KEY above.',
+    ...keys.map((input) => `${input.name}={${input.name}}`),
+    ...agentSections(),
+    '',
+    '# Extra KEY=value lines are passed through to launches.',
+    '',
+  ].join('\n');
+}