@link-assistant/agent 0.26.4 → 0.26.6

package/README.md

@@ -347,6 +347,8 @@ Commands:
 
 See [docs/stdin-mode.md](../docs/stdin-mode.md) for comprehensive stdin mode documentation.
 
+Hosts that embed the CLI supply configuration through `LINK_ASSISTANT_AGENT_CONFIG_DIR`, `LINK_ASSISTANT_AGENT_CONFIG` or `LINK_ASSISTANT_AGENT_CONFIG_CONTENT` — never by relocating `XDG_CONFIG_HOME`, which would also hide `gh`/`git` credentials from the agent's tool calls. See [docs/host-integration.md](../docs/host-integration.md).
+
 ### JSON Output Standards
 
 The agent supports two JSON output format standards via the `--json-standard` option:
@@ -773,6 +775,7 @@ For full documentation, see the [main README](../README.md) in the repository ro
 - [Tools Reference](../TOOLS.md)
 - [Usage Examples](../EXAMPLES.md)
 - [Testing Guide](../TESTING.md)
+- [Host Integration](../docs/host-integration.md) — supplying config via `LINK_ASSISTANT_AGENT_CONFIG_DIR`, `LINK_ASSISTANT_AGENT_CONFIG` and `LINK_ASSISTANT_AGENT_CONFIG_CONTENT`
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/agent",
-  "version": "0.26.4",
+  "version": "0.26.6",
   "description": "A minimal, public domain AI CLI agent compatible with OpenCode's JSON interface. Bun-only runtime.",
   "main": "src/index.js",
   "type": "module",

package/src/cli/event-handler.js

@@ -96,6 +96,7 @@ export function outputBusEvent({
           type: 'error',
           timestamp: Date.now(),
           sessionID,
+          part,
           message: errorText(stateError, 'Tool execution failed'),
           error: stateError || 'Tool execution failed',
         });

package/src/cli/model-config.js

@@ -358,6 +358,52 @@ async function resolveCompactionModelEntry(
   };
 }
 
+/**
+ * Resolve a built-in cascade entry against the run's own provider only.
+ *
+ * The built-in cascade is narrowed to the configured provider anyway (#307),
+ * so resolving its short names across the whole provider registry only to
+ * drop the result afterwards was wasted work — and it logged records such as
+ * `{"providerID":"opencode","message":"resolved short model name"}` that a
+ * host reads as the run using OpenCode (#313). Only the base provider's own
+ * catalog is consulted here; any other provider is never looked up.
+ *
+ * @returns {Promise<{providerID: string, modelID: string, useSameModel: boolean} | null>}
+ *   the entry, or `null` when the base provider does not serve it
+ * @see https://github.com/link-assistant/agent/issues/313
+ */
+async function resolveEntryWithinProvider(
+  modelArg,
+  baseProviderID,
+  baseModelID
+) {
+  if (modelArg.toLowerCase() === 'same') {
+    return {
+      providerID: baseProviderID,
+      modelID: baseModelID,
+      useSameModel: true,
+    };
+  }
+
+  if (modelArg.includes('/')) {
+    const parts = modelArg.split('/');
+    if (parts[0] !== baseProviderID) {
+      return null;
+    }
+    return {
+      providerID: parts[0],
+      modelID: parts.slice(1).join('/'),
+      useSameModel: false,
+    };
+  }
+
+  const { Provider } = await import('../provider/provider.ts');
+  if (!(await Provider.hasModel(baseProviderID, modelArg))) {
+    return null;
+  }
+  return { providerID: baseProviderID, modelID: modelArg, useSameModel: false };
+}
+
 /**
  * Narrow a built-in compaction default to the provider the run was pointed at.
  *
@@ -376,19 +422,17 @@ async function resolveCompactionModelEntry(
  * provider keeps the shipped cascade, whose extra entries are the rate-limit
  * fallbacks it was written for.
  *
- * @param {{providerID: string, modelID: string, useSameModel: boolean}[]} entries
+ * @param {{providerID: string, modelID: string, useSameModel: boolean}[]} kept
+ *   Entries served by the base provider
+ * @param {string[]} dropped Default entries, as written, that were left out
  * @param {string} baseProviderID Provider of the model that runs the turns
  * @param {string} baseModelID Model that runs the turns
  * @returns {{providerID: string, modelID: string, useSameModel: boolean}[]}
  * @see https://github.com/link-assistant/agent/issues/307
  */
-function inheritBaseProvider(entries, baseProviderID, baseModelID) {
-  const kept = entries.filter(
-    (entry) => entry.useSameModel || entry.providerID === baseProviderID
-  );
-  const dropped = entries.filter((entry) => !kept.includes(entry));
+function inheritBaseProvider(kept, dropped, baseProviderID, baseModelID) {
   if (dropped.length === 0) {
-    return entries;
+    return kept;
   }
 
   const inherited =
@@ -407,7 +451,9 @@ function inheritBaseProvider(entries, baseProviderID, baseModelID) {
     hint: 'Secondary calls (compaction, session summary) inherit --model unless a compaction model is named explicitly',
     baseProviderID,
     baseModelID,
-    dropped: dropped.map((entry) => `${entry.providerID}/${entry.modelID}`),
+    // The names as written in the default: they were never resolved, so they
+    // say nothing about which provider would have served them (#313).
+    dropped,
     kept: inherited.map((entry) =>
       entry.useSameModel ? 'same' : `${entry.providerID}/${entry.modelID}`
     ),
@@ -459,9 +505,30 @@ async function parseCompactionModelConfig(
   const modelNames = parseLinksNotationSequence(compactionModelsArg);
 
   if (modelNames.length > 0) {
-    // Resolve each model in the cascade
+    // A cascade nobody asked for must not reach across providers (#307), and
+    // is not even resolved against other providers (#313).
+    const builtInCascade =
+      compactionModelsSource === 'default' &&
+      getDefaultCompactionModelsSource(defaultOptions) === 'default';
+    const usingBuiltInCascade =
+      builtInCascade && baseProviderID !== DEFAULT_PROVIDER_ID;
+
     const compactionModels = [];
+    const unavailable = [];
     for (const name of modelNames) {
+      if (usingBuiltInCascade) {
+        const entry = await resolveEntryWithinProvider(
+          name,
+          baseProviderID,
+          baseModelID
+        );
+        if (entry) {
+          compactionModels.push(entry);
+        } else {
+          unavailable.push(name);
+        }
+        continue;
+      }
       try {
         const resolved = await resolveCompactionModelEntry(
           name,
@@ -474,6 +541,12 @@ async function parseCompactionModelConfig(
           useSameModel: resolved.useSameModel,
         });
       } catch (err) {
+        // A model nobody asked for is not an error worth a record of its
+        // own (#313); the summary below lists it.
+        if (builtInCascade) {
+          unavailable.push(name);
+          continue;
+        }
         const logSkip =
           compactionModelsSource === 'default'
             ? Log.Default.debug
@@ -486,13 +559,13 @@ async function parseCompactionModelConfig(
       }
     }
 
-    // A cascade nobody asked for must not reach across providers (#307).
-    const usingBuiltInCascade =
-      compactionModelsSource === 'default' &&
-      getDefaultCompactionModelsSource(defaultOptions) === 'default' &&
-      baseProviderID !== DEFAULT_PROVIDER_ID;
     const cascade = usingBuiltInCascade
-      ? inheritBaseProvider(compactionModels, baseProviderID, baseModelID)
+      ? inheritBaseProvider(
+          compactionModels,
+          unavailable,
+          baseProviderID,
+          baseModelID
+        )
       : compactionModels;
 
     Log.Default.info(() => ({
@@ -501,6 +574,9 @@ async function parseCompactionModelConfig(
         m.useSameModel ? 'same' : `${m.providerID}/${m.modelID}`
       ),
       source: compactionModelsSource,
+      ...(unavailable.length > 0 && !usingBuiltInCascade
+        ? { unavailable }
+        : {}),
     }));
 
     // Use the first model as the primary compaction model (for backward compatibility)
@@ -543,9 +619,17 @@ async function parseCompactionModelConfig(
     compactionModelSource === 'default' &&
     getDefaultCompactionModelSource(defaultOptions) === 'default' &&
     baseProviderID !== DEFAULT_PROVIDER_ID;
-  const [entry] = usingBuiltInCompactionModel
-    ? inheritBaseProvider([resolved], baseProviderID, baseModelID)
-    : [resolved];
+  const [entry] =
+    usingBuiltInCompactionModel &&
+    !resolved.useSameModel &&
+    resolved.providerID !== baseProviderID
+      ? inheritBaseProvider(
+          [],
+          [compactionModelArg],
+          baseProviderID,
+          baseModelID
+        )
+      : [resolved];
 
   Log.Default.info(() => ({
     message: 'using single compaction model',

package/src/config/host-config-hint.ts

@@ -0,0 +1,62 @@
+import os from 'os';
+import path from 'path';
+
+/**
+ * Host integration contract: how an embedding host hands the CLI its config.
+ *
+ * A host supplies configuration through the CLI's own variables:
+ *
+ *   LINK_ASSISTANT_AGENT_CONFIG_DIR      a directory holding opencode.json(c)
+ *   LINK_ASSISTANT_AGENT_CONFIG          a single config file
+ *   LINK_ASSISTANT_AGENT_CONFIG_CONTENT  the config itself, as JSON
+ *
+ * Relocating `XDG_CONFIG_HOME` to feed the CLI a generated config also moves
+ * the config home of every tool the agent runs — `gh` then finds no
+ * `hosts.yml` and the session loses GitHub authentication (#314). This module
+ * spots that setup so the CLI can point the host at the variables above.
+ *
+ * @see https://github.com/link-assistant/agent/issues/314
+ * @see ../../../docs/host-integration.md
+ */
+export namespace HostConfigHint {
+  export const CONFIG_ENV_VARS = [
+    'LINK_ASSISTANT_AGENT_CONFIG_DIR',
+    'LINK_ASSISTANT_AGENT_CONFIG',
+    'LINK_ASSISTANT_AGENT_CONFIG_CONTENT',
+  ] as const;
+
+  export interface Hint {
+    message: string;
+    xdgConfigHome: string;
+    realConfigHome: string;
+    hint: string;
+  }
+
+  /**
+   * Return a hint when `XDG_CONFIG_HOME` points away from the user's real
+   * config home and none of the CLI's own config variables is set — the
+   * signature of a host relocating XDG to deliver config. Pure, so it can be
+   * tested with any environment.
+   */
+  export function detect(
+    env: Record<string, string | undefined> = process.env,
+    homedir: string = os.homedir()
+  ): Hint | undefined {
+    const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
+    if (!xdgConfigHome) return undefined;
+
+    const realConfigHome = path.join(homedir, '.config');
+    if (path.resolve(xdgConfigHome) === path.resolve(realConfigHome)) {
+      return undefined;
+    }
+
+    if (CONFIG_ENV_VARS.some((name) => env[name]?.trim())) return undefined;
+
+    return {
+      message: 'XDG_CONFIG_HOME is relocated',
+      xdgConfigHome,
+      realConfigHome,
+      hint: `To supply agent config, set ${CONFIG_ENV_VARS.join(', ')} instead of XDG_CONFIG_HOME: tools the agent runs (gh, git) read their config and credentials from XDG_CONFIG_HOME too`,
+    };
+  }
+}

package/src/index.js

@@ -7,6 +7,7 @@ import {
   getConfigSnapshot,
 } from './config/config.ts';
 import { setProcessName } from './cli/process-name.ts';
+import { HostConfigHint } from './config/host-config-hint.ts';
 setProcessName('agent');
 import { Server } from './server/server.ts';
 import { Instance } from './project/instance.ts';
@@ -909,6 +910,13 @@ async function main() {
           config: getConfigSnapshot(),
         }));
 
+        // A host that relocates XDG_CONFIG_HOME to deliver agent config also
+        // hides gh/git credentials from the agent's tool calls (#314).
+        const hostConfigHint = HostConfigHint.detect();
+        if (hostConfigHint) {
+          Log.Default.warn(() => hostConfigHint);
+        }
+
         // Global fetch monkey-patch for verbose HTTP logging (#221).
         if (!globalThis.__agentVerboseFetchInstalled) {
           globalThis.fetch = createVerboseFetch(globalThis.fetch, {

package/src/json-standard/index.ts

@@ -28,6 +28,7 @@ export interface OpenCodeEvent {
   timestamp: number;
   sessionID: string;
   part?: Record<string, unknown>;
+  message?: string;
   error?: string | Record<string, unknown>;
 }
 
@@ -116,12 +117,44 @@ export function convertOpenCodeToClaude(
     case 'tool_use':
       if (event.part && event.part.state) {
         const state = event.part.state as Record<string, unknown>;
+        const input = state.input || {};
+        const status = state.status as string | undefined;
+
+        // A newly-created pending part has not received its parsed arguments
+        // yet. Populated pending parts are retained for compatibility with
+        // producers that publish the complete call in their first snapshot.
+        if (
+          status === 'pending' &&
+          typeof input === 'object' &&
+          input !== null &&
+          Object.keys(input).length === 0
+        ) {
+          return null;
+        }
+
+        if (status === 'completed') {
+          return {
+            type: 'tool_result',
+            timestamp,
+            session_id,
+            tool_use_id: event.part.id as string,
+            output: state.output as string,
+            status: 'success',
+          };
+        }
+
+        // outputBusEvent follows an errored tool snapshot with an error event
+        // carrying the same part, which is converted to the terminal result.
+        if (status === 'error') {
+          return null;
+        }
+
         return {
           type: 'tool_use',
           timestamp,
           session_id,
           name: (event.part.tool as string) || 'unknown',
-          input: state.input || {},
+          input,
           tool_use_id: event.part.id as string,
         };
       }
@@ -144,6 +177,21 @@ export function convertOpenCodeToClaude(
       };
 
     case 'error':
+      if (event.part?.type === 'tool' && event.part.state) {
+        const state = event.part.state as Record<string, unknown>;
+        return {
+          type: 'tool_result',
+          timestamp,
+          session_id,
+          tool_use_id: event.part.id as string,
+          output:
+            event.message ||
+            (typeof state.error === 'string'
+              ? state.error
+              : 'Tool execution failed'),
+          status: 'error',
+        };
+      }
       return {
         type: 'result',
         timestamp,
@@ -173,6 +221,8 @@ export function createEventHandler(
 ) {
   const startTime = Date.now();
   const { model } = options;
+  const emittedToolUseIds = new Set<string>();
+  const emittedToolResultIds = new Set<string>();
 
   return {
     /**
@@ -184,6 +234,14 @@ export function createEventHandler(
       if (standard === 'claude') {
         const claudeEvent = convertOpenCodeToClaude(event, startTime, model);
         if (claudeEvent) {
+          if (claudeEvent.type === 'tool_use' && claudeEvent.tool_use_id) {
+            if (emittedToolUseIds.has(claudeEvent.tool_use_id)) return;
+            emittedToolUseIds.add(claudeEvent.tool_use_id);
+          }
+          if (claudeEvent.type === 'tool_result' && claudeEvent.tool_use_id) {
+            if (emittedToolResultIds.has(claudeEvent.tool_use_id)) return;
+            emittedToolResultIds.add(claudeEvent.tool_use_id);
+          }
           outputStream.write(serializeOutput(claudeEvent, standard));
         }
       } else {

package/src/provider/provider.ts

@@ -38,6 +38,14 @@ import { createGroq } from '@ai-sdk/groq';
 
 export namespace Provider {
   const log = Log.create({ service: 'provider' });
+  /**
+   * Catalog lookups — which providers are installed, which provider a short
+   * model name would map to — describe candidates, not the model a run uses.
+   * They are logged under their own service and never carry `providerID` /
+   * `modelID` fields, which stream consumers read as the run's model identity
+   * (#313). The active model is attested by the `model_resolved` event.
+   */
+  const registryLog = Log.create({ service: 'provider-registry' });
 
   /**
    * Bundled providers - these are pre-installed and imported statically
@@ -1235,8 +1243,11 @@ export namespace Provider {
         delete providers[providerID];
         continue;
       }
-      log.info(() => ({ message: 'found', providerID }));
     }
+    registryLog.info(() => ({
+      message: 'providers available',
+      available: Object.keys(providers),
+    }));
 
     return {
       models,
@@ -1696,6 +1707,15 @@ export namespace Provider {
     return state().then((s) => s.providers[providerID]);
   }
 
+  /**
+   * Whether a provider's catalog lists a model. Looks at that one provider
+   * only and logs nothing (#313).
+   */
+  export async function hasModel(providerID: string, modelID: string) {
+    const provider = await getProvider(providerID);
+    return Boolean(provider?.info.models[modelID]);
+  }
+
   async function getLiveModelInfo(providerID: string, modelID: string) {
     if (providerID !== 'opencode') return undefined;
     return OpenCodeZen.getLiveFreeModelInfo(modelID);
@@ -2084,9 +2104,10 @@ export namespace Provider {
     if (kiloUniqueModels.includes(modelID)) {
       const kiloProvider = s.providers['kilo'];
       if (kiloProvider && kiloProvider.info.models[modelID]) {
-        log.info(() => ({
+        registryLog.info(() => ({
           message: 'resolved short model name to kilo (unique)',
-          modelID,
+          name: modelID,
+          candidate: `kilo/${modelID}`,
         }));
         return { providerID: 'kilo', modelID };
       }
@@ -2095,9 +2116,10 @@ export namespace Provider {
     if (modelID === 'formal-ai') {
       const formalAiProvider = s.providers['formal-ai'];
       if (formalAiProvider && formalAiProvider.info.models[modelID]) {
-        log.info(() => ({
+        registryLog.info(() => ({
           message: 'resolved short model name to formal-ai (canonical)',
-          modelID,
+          name: modelID,
+          candidate: `formal-ai/${modelID}`,
         }));
         return { providerID: 'formal-ai', modelID };
       }
@@ -2117,10 +2139,10 @@ export namespace Provider {
 
     if (matchingProviders.length === 1) {
       const providerID = matchingProviders[0];
-      log.info(() => ({
+      registryLog.info(() => ({
         message: 'resolved short model name (single match)',
-        modelID,
-        providerID,
+        name: modelID,
+        candidate: `${providerID}/${modelID}`,
       }));
       return { providerID, modelID };
     }
@@ -2128,9 +2150,10 @@ export namespace Provider {
     // Multiple providers have this model - prefer OpenCode for shared free models
     // This follows the convention that opencode is the primary free provider
     if (matchingProviders.includes('opencode')) {
-      log.info(() => ({
+      registryLog.info(() => ({
         message: 'resolved short model name to opencode (multiple providers)',
-        modelID,
+        name: modelID,
+        candidate: `opencode/${modelID}`,
         availableProviders: matchingProviders,
       }));
       return { providerID: 'opencode', modelID };
@@ -2138,10 +2161,10 @@ export namespace Provider {
 
     // Fallback to first matching provider
     const providerID = matchingProviders[0];
-    log.info(() => ({
+    registryLog.info(() => ({
       message: 'resolved short model name (fallback)',
-      modelID,
-      providerID,
+      name: modelID,
+      candidate: `${providerID}/${modelID}`,
       availableProviders: matchingProviders,
     }));
     return { providerID, modelID };