@duetso/agent 0.2.6 → 0.3.1

package/dist/src/memory-store.js

@@ -0,0 +1,554 @@
+// src/memory/store/file.ts
+import { Buffer } from "node:buffer";
+import { basename } from "node:path";
+var MAX_TRAIN_RECORD_CONTENT_BYTES = 10 * 1024 * 1024;
+var SLUG_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var ID_SEGMENT_PATTERN = /^[A-Za-z0-9_-]+$/;
+var KEY_PATTERN = /^[A-Za-z][A-Za-z0-9]*$/;
+var NUMBER_PATTERN = /^-?(?:0|[1-9]\d*)(?:\.\d+)?$/;
+var KNOWN_KEYS = [
+  "version",
+  "id",
+  "kind",
+  "createdAt",
+  "headline",
+  "model",
+  "fileCount",
+  "archiveId",
+  "priority",
+  "source",
+  "tags"
+];
+var KNOWN_KEY_ORDER = new Map(KNOWN_KEYS.map((key, index) => [key, index]));
+var parsedLineEndings = new WeakMap;
+function parseMemoryFile(text) {
+  const lineEnding = text.startsWith(`---\r
+`) ? `\r
+` : text.startsWith(`---
+`) ? `
+` : undefined;
+  if (!lineEnding)
+    throw new Error("Memory file must start with a frontmatter delimiter");
+  const closingDelimiter = `${lineEnding}---${lineEnding}`;
+  const closingIndex = text.indexOf(closingDelimiter, 3 + lineEnding.length);
+  if (closingIndex === -1)
+    throw new Error("Memory file is missing its closing delimiter");
+  const header = text.slice(3 + lineEnding.length, closingIndex);
+  const content = text.slice(closingIndex + closingDelimiter.length);
+  assertContent(content);
+  const values = new Map;
+  let lastKnownIndex = -1;
+  let sawUnknown = false;
+  for (const line of header.split(lineEnding)) {
+    const separator = line.indexOf(": ");
+    if (separator <= 0)
+      throw new Error(`Invalid frontmatter line: ${line}`);
+    const key = line.slice(0, separator);
+    const rawValue = line.slice(separator + 2);
+    if (!KEY_PATTERN.test(key))
+      throw new Error(`Invalid frontmatter key: ${key}`);
+    if (values.has(key))
+      throw new Error(`Duplicate frontmatter key: ${key}`);
+    if (key === "sourceFolder") {
+      throw new Error("sourceFolder is private archive metadata and cannot enter a memory file");
+    }
+    const knownIndex = KNOWN_KEY_ORDER.get(key);
+    if (knownIndex === undefined) {
+      sawUnknown = true;
+    } else {
+      if (sawUnknown || knownIndex <= lastKnownIndex) {
+        throw new Error(`Frontmatter key is out of canonical order: ${key}`);
+      }
+      lastKnownIndex = knownIndex;
+    }
+    values.set(key, parseScalar(rawValue));
+  }
+  const version = requireNumber(values, "version");
+  if (version !== 1)
+    throw new Error(`Unsupported memory file version: ${version}`);
+  const kind = requireString(values, "kind");
+  if (kind !== "train" && kind !== "note")
+    throw new Error(`Invalid memory kind: ${kind}`);
+  const createdAt = requireNumber(values, "createdAt");
+  if (!Number.isSafeInteger(createdAt) || createdAt < 0) {
+    throw new Error("createdAt must be a non-negative integer");
+  }
+  const fileCount = optionalNumber(values, "fileCount");
+  if (fileCount !== undefined && (!Number.isSafeInteger(fileCount) || fileCount < 0)) {
+    throw new Error("fileCount must be a non-negative integer");
+  }
+  const record = {
+    version: 1,
+    id: requireIdSegment(values, "id"),
+    kind,
+    createdAt,
+    ...optionalStringProperty(values, "headline"),
+    ...optionalStringProperty(values, "model"),
+    ...fileCount === undefined ? {} : { fileCount },
+    ...optionalIdSegmentProperty(values, "archiveId"),
+    ...optionalStringProperty(values, "priority"),
+    ...optionalStringProperty(values, "source"),
+    ...optionalStringArrayProperty(values, "tags"),
+    ...extraProperties(values),
+    content
+  };
+  parsedLineEndings.set(record, lineEnding);
+  return record;
+}
+function serializeMemoryFile(record) {
+  validateRecord(record);
+  const lineEnding = parsedLineEndings.get(record) ?? `
+`;
+  const fields = [
+    ["version", record.version],
+    ["id", record.id],
+    ["kind", record.kind],
+    ["createdAt", record.createdAt]
+  ];
+  appendOptional(fields, "headline", record.headline);
+  appendOptional(fields, "model", record.model);
+  appendOptional(fields, "fileCount", record.fileCount);
+  appendOptional(fields, "archiveId", record.archiveId);
+  appendOptional(fields, "priority", record.priority);
+  appendOptional(fields, "source", record.source);
+  appendOptional(fields, "tags", record.tags);
+  for (const [key, value] of Object.entries(record.extra ?? {})) {
+    if (!KEY_PATTERN.test(key) || KNOWN_KEY_ORDER.has(key) || key === "sourceFolder") {
+      throw new Error(`Invalid extra frontmatter key: ${key}`);
+    }
+    fields.push([key, value]);
+  }
+  const header = fields.map(([key, value]) => `${key}: ${serializeScalar(value)}`).join(lineEnding);
+  return `---${lineEnding}${header}${lineEnding}---${lineEnding}${record.content}`;
+}
+function slugFromFilename(name) {
+  if (basename(name) !== name || !name.endsWith(".md")) {
+    throw new Error(`Memory filename must be a bare .md filename: ${name}`);
+  }
+  const slug = name.slice(0, -3);
+  if (!SLUG_PATTERN.test(slug))
+    throw new Error(`Unsafe memory slug: ${slug}`);
+  return slug;
+}
+function parseScalar(rawValue) {
+  if (NUMBER_PATTERN.test(rawValue)) {
+    const value = Number(rawValue);
+    if (Number.isFinite(value) && String(value) === rawValue)
+      return value;
+  }
+  try {
+    const value = JSON.parse(rawValue);
+    if (typeof value === "string" && JSON.stringify(value) === rawValue)
+      return value;
+    if (Array.isArray(value) && value.every((item) => typeof item === "string") && `[${value.map((item) => JSON.stringify(item)).join(", ")}]` === rawValue) {
+      return value;
+    }
+  } catch {}
+  throw new Error(`Unsupported frontmatter scalar: ${rawValue}`);
+}
+function serializeScalar(value) {
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || /[eE]/.test(String(value))) {
+      throw new Error(`Frontmatter numbers must be finite decimals: ${value}`);
+    }
+    return String(value);
+  }
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return `[${value.map((item) => JSON.stringify(item)).join(", ")}]`;
+  }
+  throw new Error("Frontmatter values must be strings, numbers, or string arrays");
+}
+function requireNumber(values, key) {
+  const value = values.get(key);
+  if (typeof value !== "number")
+    throw new Error(`Frontmatter ${key} must be a number`);
+  return value;
+}
+function optionalNumber(values, key) {
+  const value = values.get(key);
+  if (value === undefined)
+    return;
+  if (typeof value !== "number")
+    throw new Error(`Frontmatter ${key} must be a number`);
+  return value;
+}
+function requireString(values, key) {
+  const value = values.get(key);
+  if (typeof value !== "string")
+    throw new Error(`Frontmatter ${key} must be a string`);
+  return value;
+}
+function requireNonBlankString(values, key) {
+  const value = requireString(values, key);
+  if (value.trim().length === 0)
+    throw new Error(`Frontmatter ${key} cannot be blank`);
+  return value;
+}
+function requireIdSegment(values, key) {
+  return assertIdSegment(key, requireNonBlankString(values, key));
+}
+function optionalIdSegmentProperty(values, key) {
+  if (!values.has(key))
+    return {};
+  return { [key]: requireIdSegment(values, key) };
+}
+function assertIdSegment(key, value) {
+  if (!ID_SEGMENT_PATTERN.test(value)) {
+    throw new Error(`Frontmatter ${key} must be a safe path segment: ${value}`);
+  }
+  return value;
+}
+function optionalStringProperty(values, key) {
+  if (!values.has(key))
+    return {};
+  return { [key]: requireNonBlankString(values, key) };
+}
+function optionalStringArrayProperty(values, key) {
+  const value = values.get(key);
+  if (value === undefined)
+    return {};
+  if (!Array.isArray(value) || value.some((item) => item.trim().length === 0)) {
+    throw new Error(`Frontmatter ${key} must be a string array without blank items`);
+  }
+  return { tags: value };
+}
+function extraProperties(values) {
+  const extra = Object.fromEntries(Array.from(values).filter(([key]) => !KNOWN_KEY_ORDER.has(key)));
+  return Object.keys(extra).length === 0 ? {} : { extra };
+}
+function appendOptional(fields, key, value) {
+  if (value !== undefined)
+    fields.push([key, value]);
+}
+function validateRecord(record) {
+  if (record.version !== 1)
+    throw new Error(`Unsupported memory file version: ${record.version}`);
+  if (record.id.trim().length === 0)
+    throw new Error("Frontmatter id cannot be blank");
+  assertIdSegment("id", record.id);
+  if (record.archiveId !== undefined)
+    assertIdSegment("archiveId", record.archiveId);
+  if (record.kind !== "train" && record.kind !== "note") {
+    throw new Error(`Invalid memory kind: ${String(record.kind)}`);
+  }
+  if (!Number.isSafeInteger(record.createdAt) || record.createdAt < 0) {
+    throw new Error("createdAt must be a non-negative integer");
+  }
+  if (record.fileCount !== undefined && (!Number.isSafeInteger(record.fileCount) || record.fileCount < 0)) {
+    throw new Error("fileCount must be a non-negative integer");
+  }
+  for (const [key, value] of Object.entries({
+    headline: record.headline,
+    model: record.model,
+    archiveId: record.archiveId,
+    priority: record.priority,
+    source: record.source
+  })) {
+    if (value !== undefined && value.trim().length === 0) {
+      throw new Error(`Frontmatter ${key} cannot be blank`);
+    }
+  }
+  if (record.tags?.some((tag) => tag.trim().length === 0)) {
+    throw new Error("Frontmatter tags cannot contain blank items");
+  }
+  assertContent(record.content);
+}
+function assertContent(content) {
+  if (content.trim().length === 0)
+    throw new Error("Memory content cannot be blank");
+  const bytes = Buffer.byteLength(content, "utf8");
+  if (bytes > MAX_TRAIN_RECORD_CONTENT_BYTES) {
+    throw new Error(`Memory content exceeds ${MAX_TRAIN_RECORD_CONTENT_BYTES} UTF-8 bytes`);
+  }
+}
+// src/memory/store/discovery.ts
+import { lstat } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/lib/walk-ancestors.ts
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+function walkAncestors(cwd, home = homedir()) {
+  const resolvedHome = resolve(home);
+  const seen = new Set;
+  const result = [];
+  let current = resolve(cwd);
+  while (true) {
+    if (seen.has(current))
+      break;
+    seen.add(current);
+    if (current !== resolvedHome)
+      result.push(current);
+    const parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return result;
+}
+
+// src/memory/store/discovery.ts
+var MEMORY_ROOT_NAMES = [".duet", ".agents", ".claude"];
+async function discoverMemoryStores(cwd) {
+  const stores = [];
+  for (const ancestor of walkAncestors(cwd)) {
+    for (const rootName of MEMORY_ROOT_NAMES) {
+      const storeDir = join(ancestor, rootName, "memories");
+      const status = await lstat(storeDir).catch((error) => {
+        if (isNodeError(error, "ENOENT") || isNodeError(error, "ENOTDIR"))
+          return;
+        throw error;
+      });
+      if (!status)
+        continue;
+      if (status.isSymbolicLink())
+        throw new Error(`Memory stores cannot be symlinks: ${storeDir}`);
+      if (!status.isDirectory())
+        throw new Error(`Memory store is not a directory: ${storeDir}`);
+      stores.push(storeDir);
+    }
+  }
+  return stores;
+}
+function isNodeError(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+// src/memory/store/sources.ts
+import * as fileSystem from "node:fs/promises";
+import { join as join3, resolve as resolve2 } from "node:path";
+
+// src/memory/paths.ts
+import { homedir as homedir2 } from "node:os";
+import { join as join2 } from "node:path";
+var DEFAULT_DUET_DIR = ".duet";
+var DEFAULT_DUET_HOME = join2(homedir2(), DEFAULT_DUET_DIR);
+var DEFAULT_SESSION_STORAGE_DIR = join2(DEFAULT_DUET_HOME, "sessions");
+var DEFAULT_MEMORY_DB_PATH = join2(DEFAULT_DUET_HOME, "memory.db");
+
+// src/memory/store/sources.ts
+async function resolveSources(flags, cwd) {
+  const explicitCount = flags.stores.length + flags.dbs.length;
+  if (explicitCount > 0) {
+    const stores2 = unique(flags.stores);
+    const dbs = unique(flags.dbs);
+    const selected = flags.stores[0] ?? flags.dbs[0];
+    const writeTarget = explicitCount === 1 && selected ? { kind: flags.stores.length === 1 ? "store" : "db", path: selected } : undefined;
+    return {
+      stores: stores2,
+      dbs,
+      ...writeTarget ? { writeTarget } : {}
+    };
+  }
+  const stores = await discoverMemoryStores(cwd);
+  return {
+    stores,
+    dbs: [DEFAULT_MEMORY_DB_PATH],
+    writeTarget: { kind: "store", path: await nearestAgentMemoryStore(cwd) }
+  };
+}
+function mergeListings(storeEntries, dbEntries) {
+  const winners = new Map;
+  for (const listing of storeEntries) {
+    for (const entry of listing.entries) {
+      if (!winners.has(entry.slug))
+        winners.set(entry.slug, { ...entry, store: listing.source });
+    }
+  }
+  for (const listing of dbEntries) {
+    for (const entry of listing.entries) {
+      if (!winners.has(entry.slug))
+        winners.set(entry.slug, { ...entry });
+    }
+  }
+  return Array.from(winners.values()).sort((left, right) => right.createdAt - left.createdAt);
+}
+async function nearestAgentMemoryStore(cwd) {
+  for (const ancestor of walkAncestors(cwd)) {
+    const agentRoot = join3(ancestor, ".agents");
+    const status = await fileSystem.lstat(agentRoot).catch((error) => {
+      if (isNodeError2(error, "ENOENT") || isNodeError2(error, "ENOTDIR"))
+        return;
+      throw error;
+    });
+    if (!status)
+      continue;
+    if (status.isSymbolicLink())
+      throw new Error(`Agent directories cannot be symlinks: ${agentRoot}`);
+    if (!status.isDirectory())
+      throw new Error(`Agent path is not a directory: ${agentRoot}`);
+    return join3(agentRoot, "memories");
+  }
+  return join3(resolve2(cwd), ".agents", "memories");
+}
+function unique(paths) {
+  return Array.from(new Set(paths));
+}
+function isNodeError2(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+// src/memory/store/store.ts
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import * as fileSystem2 from "node:fs/promises";
+import { basename as basename2, join as join4, resolve as resolve3 } from "node:path";
+async function listStore(dir) {
+  return listStoreWithInvalidPolicy(dir);
+}
+async function listStoreWithInvalidPolicy(dir, onInvalidEntry) {
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    return [];
+  const directoryEntries = await fileSystem2.readdir(storeDir, { withFileTypes: true });
+  const memoryEntries = directoryEntries.filter((entry) => entry.name.endsWith(".md")).sort((left, right) => left.name.localeCompare(right.name));
+  const loaded = await Promise.all(memoryEntries.map(async (entry) => {
+    const path = join4(storeDir, entry.name);
+    try {
+      if (entry.isSymbolicLink())
+        throw new Error(`Memory files cannot be symlinks: ${entry.name}`);
+      if (!entry.isFile())
+        throw new Error(`Memory entry is not a regular file: ${entry.name}`);
+      return await readEntry(storeDir, slugFromFilename(entry.name));
+    } catch (error) {
+      if (!onInvalidEntry)
+        throw error;
+      onInvalidEntry(path, error);
+      return;
+    }
+  }));
+  return loaded.filter((entry) => entry !== undefined);
+}
+async function readEntry(dir, slug) {
+  const safeSlug = assertSlug(slug);
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    throw new Error(`Memory store does not exist: ${resolve3(dir)}`);
+  return (await readParsedEntry(storeDir, safeSlug)).stored;
+}
+async function writeEntry(dir, record) {
+  const slug = assertSlug(record.slug);
+  const bytes = serializeMemoryFile(record);
+  const storeDir = await requireStoreDirectory(dir, true);
+  if (!storeDir)
+    throw new Error("Memory store could not be created");
+  const destination = join4(storeDir, `${slug}.md`);
+  await rejectSymlinkIfPresent(destination);
+  const temporary = join4(storeDir, `.${slug}.${randomUUID()}.tmp`);
+  const handle = await fileSystem2.open(temporary, "wx", 384);
+  try {
+    try {
+      await handle.writeFile(bytes, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await fileSystem2.rename(temporary, destination);
+  } catch (error) {
+    await fileSystem2.rm(temporary, { force: true });
+    throw error;
+  }
+  return toStoredMemory(storeDir, slug, record);
+}
+async function updateEntry(dir, slug, content) {
+  const safeSlug = assertSlug(slug);
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    throw new Error(`Memory store does not exist: ${resolve3(dir)}`);
+  const { record } = await readParsedEntry(storeDir, safeSlug);
+  record.content = content;
+  return writeEntry(storeDir, Object.assign(record, { slug: safeSlug }));
+}
+async function deleteEntry(dir, slug) {
+  const safeSlug = assertSlug(slug);
+  const storeDir = await requireStoreDirectory(dir, false);
+  if (!storeDir)
+    throw new Error(`Memory store does not exist: ${resolve3(dir)}`);
+  const { stored } = await readParsedEntry(storeDir, safeSlug);
+  const path = join4(storeDir, `${safeSlug}.md`);
+  await rejectSymlinkIfPresent(path);
+  await fileSystem2.unlink(path);
+  return stored;
+}
+async function readParsedEntry(storeDir, slug) {
+  const path = join4(storeDir, `${slug}.md`);
+  const status = await fileSystem2.lstat(path);
+  if (status.isSymbolicLink())
+    throw new Error(`Memory files cannot be symlinks: ${path}`);
+  if (!status.isFile())
+    throw new Error(`Memory entry is not a regular file: ${path}`);
+  const handle = await fileSystem2.open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+  const text = await handle.readFile("utf8").finally(() => handle.close());
+  const record = parseMemoryFile(text);
+  return { stored: toStoredMemory(storeDir, slug, record), record };
+}
+function toStoredMemory(storeDir, slug, record) {
+  return {
+    slug,
+    storeDir,
+    id: record.id,
+    kind: record.kind,
+    createdAt: record.createdAt,
+    ...record.headline === undefined ? {} : { headline: record.headline },
+    ...record.model === undefined ? {} : { model: record.model },
+    ...record.fileCount === undefined ? {} : { fileCount: record.fileCount },
+    ...record.archiveId === undefined ? {} : { archiveId: record.archiveId },
+    content: record.content
+  };
+}
+function assertSlug(slug) {
+  if (basename2(slug) !== slug)
+    throw new Error(`Unsafe memory slug: ${slug}`);
+  return slugFromFilename(`${slug}.md`);
+}
+async function requireStoreDirectory(dir, create) {
+  const storeDir = resolve3(dir);
+  const status = await fileSystem2.lstat(storeDir).catch((error) => {
+    if (isNodeError3(error, "ENOENT"))
+      return;
+    throw error;
+  });
+  if (!status && create) {
+    await fileSystem2.mkdir(storeDir, { recursive: true, mode: 448 });
+    const createdStatus = await fileSystem2.lstat(storeDir);
+    if (!createdStatus.isDirectory() || createdStatus.isSymbolicLink()) {
+      throw new Error(`Memory store must be a real directory: ${storeDir}`);
+    }
+    return storeDir;
+  }
+  if (!status)
+    return;
+  if (status.isSymbolicLink())
+    throw new Error(`Memory stores cannot be symlinks: ${storeDir}`);
+  if (!status.isDirectory())
+    throw new Error(`Memory store is not a directory: ${storeDir}`);
+  return storeDir;
+}
+async function rejectSymlinkIfPresent(path) {
+  const status = await fileSystem2.lstat(path).catch((error) => {
+    if (isNodeError3(error, "ENOENT"))
+      return;
+    throw error;
+  });
+  if (status?.isSymbolicLink())
+    throw new Error(`Memory files cannot be symlinks: ${path}`);
+  if (status && !status.isFile())
+    throw new Error(`Memory entry is not a regular file: ${path}`);
+}
+function isNodeError3(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
+}
+export {
+  writeEntry,
+  updateEntry,
+  slugFromFilename,
+  serializeMemoryFile,
+  resolveSources,
+  readEntry,
+  parseMemoryFile,
+  mergeListings,
+  listStore,
+  discoverMemoryStores,
+  deleteEntry,
+  MAX_TRAIN_RECORD_CONTENT_BYTES
+};

package/dist/src/model-resolution/catalog.d.ts

@@ -1,13 +1,19 @@
-export type ProviderName = "duet-gateway" | "vercel-ai-gateway" | "openrouter";
+import type { ConnectedProviderId } from "../connected-providers/store.js";
+/** Metered providers considered by the router when resolving an unpinned model. */
+export type RouterProviderName = "duet-gateway" | "vercel-ai-gateway" | "openrouter";
+/** Any backend capable of carrying a curated catalog model. */
+export type TransportName = RouterProviderName | ConnectedProviderId;
+/** Versionless model families accepted anywhere a curated shorthand is accepted. */
+export type FamilyName = "fable" | "opus" | "sonnet" | "haiku" | "sol" | "terra" | "luna" | "kimi" | "grok" | "deepseek" | "glm";
 export interface ProviderPreference {
     /** Provider identifier accepted by pi-ai or handled locally by model resolution. */
-    provider: ProviderName;
+    provider: RouterProviderName;
     /** Env var override for providers whose credential is not discoverable through pi-ai. */
     customEnvVar?: () => string | null;
 }
 export interface ProviderModelCandidate {
     /** Provider that supports the candidate model. */
-    provider: ProviderName;
+    provider: RouterProviderName;
     /** Fully resolved provider:modelId string passed to the runtime model loader. */
     modelName: string;
 }
@@ -19,6 +25,10 @@ export declare const DEFAULT_CLI_MEMORY_MODEL = "gpt-5.6-luna";
  * AI_GATEWAY_API_KEY for the gateway transport.
  */
 export declare const PROVIDER_ORDER: readonly ProviderPreference[];
+/** Latest shorthand for each family, derived from the first matching catalog entry. */
+export declare const FAMILY_LATEST: Readonly<Record<FamilyName, string>>;
+/** Resolve a versionless family name to the first versioned shorthand in catalog order. */
+export declare function resolveFamilyShorthand(name: string): string | undefined;
 export declare function isProviderPinnedModelName(modelName: string): boolean;
 /**
  * Clamp a resolved model's output-token ceiling to the catalog's
@@ -30,28 +40,32 @@ export declare function clampModelOutputTokens<T extends {
     id: string;
     maxTokens: number;
 }>(model: T): T;
-export declare function getProviderDefaultModel(provider: ProviderName): string;
-export declare function getProviderMemoryModel(provider: ProviderName): string;
+export declare function getProviderDefaultModel(provider: RouterProviderName): string;
+export declare function getProviderMemoryModel(provider: RouterProviderName): string;
 export declare function getModelCandidates(modelName: string): readonly ProviderModelCandidate[];
 export declare function isKnownShorthand(modelName: string): boolean;
 export declare function canonicalizeModelName(modelName: string): string;
+/** Resolve a curated shorthand or alias to the id served by a specific transport. */
+export declare function transportModelId(transport: TransportName, shorthand: string): string | undefined;
+/** Recover the curated shorthand represented by a transport-specific model id. */
+export declare function shorthandForTransportModel(transport: TransportName, modelId: string): string | undefined;
 /**
  * Normalize a `provider:modelId` model id against catalog aliases so users can
  * pass familiar variants like `claude-opus-4-7` even when the underlying
  * provider catalog spells it `claude-opus-4.7`. Falls back to the input id
  * when no alias matches so unknown ids reach the provider lookup unchanged.
  */
-export declare function canonicalizeProviderModelId(provider: ProviderName, modelId: string): string;
+export declare function canonicalizeProviderModelId(provider: RouterProviderName, modelId: string): string;
 /**
  * Map user-friendly provider names (and common aliases) onto the canonical
- * `ProviderName`. Returns `undefined` for unknown values so callers can
+ * `RouterProviderName`. Returns `undefined` for unknown values so callers can
  * surface a list of accepted names.
  */
-export declare function resolveProviderShorthand(name: string): ProviderName | undefined;
+export declare function resolveProviderShorthand(name: string): RouterProviderName | undefined;
 /** Names accepted by `--provider`, in canonical order, for help and errors. */
 export declare const PROVIDER_SHORTHANDS: readonly string[];
 /** Build a `provider:modelId` reference for a provider's default chat model. */
-export declare function pinnedDefaultModel(provider: ProviderName): string;
+export declare function pinnedDefaultModel(provider: RouterProviderName): string;
 /** Build a `provider:modelId` reference for a provider's memory model. */
-export declare function pinnedMemoryModel(provider: ProviderName): string;
+export declare function pinnedMemoryModel(provider: RouterProviderName): string;
 //# sourceMappingURL=catalog.d.ts.map

package/dist/src/model-resolution/catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/model-resolution/catalog.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,GAAG,cAAc,GAAG,mBAAmB,GAAG,YAAY,CAAC;AAE/E,MAAM,WAAW,kBAAkB;IACjC,oFAAoF;IACpF,QAAQ,EAAE,YAAY,CAAC;IACvB,yFAAyF;IACzF,YAAY,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,sBAAsB;IACrC,kDAAkD;IAClD,QAAQ,EAAE,YAAY,CAAC;IACvB,iFAAiF;IACjF,SAAS,EAAE,MAAM,CAAC;CACnB;AAeD,eAAO,MAAM,iBAAiB,aAAa,CAAC;AAC5C,eAAO,MAAM,wBAAwB,iBAAiB,CAAC;AAEvD;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,kBAAkB,EAOvD,CAAC;AAkOF,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAQ/F;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAEtE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAErE;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,sBAAsB,EAAE,CAQvF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAI3F;AASD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAe/E;AAED,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAqC,CAAC;AAEvF,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAEjE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAEhE"}
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/model-resolution/catalog.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AAE3E,mFAAmF;AACnF,MAAM,MAAM,kBAAkB,GAAG,cAAc,GAAG,mBAAmB,GAAG,YAAY,CAAC;AAErF,+DAA+D;AAC/D,MAAM,MAAM,aAAa,GAAG,kBAAkB,GAAG,mBAAmB,CAAC;AAErE,oFAAoF;AACpF,MAAM,MAAM,UAAU,GAClB,OAAO,GACP,MAAM,GACN,QAAQ,GACR,OAAO,GACP,KAAK,GACL,OAAO,GACP,MAAM,GACN,MAAM,GACN,MAAM,GACN,UAAU,GACV,KAAK,CAAC;AAEV,MAAM,WAAW,kBAAkB;IACjC,oFAAoF;IACpF,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,yFAAyF;IACzF,YAAY,CAAC,EAAE,MAAM,MAAM,GAAG,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,sBAAsB;IACrC,kDAAkD;IAClD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,iFAAiF;IACjF,SAAS,EAAE,MAAM,CAAC;CACnB;AAkBD,eAAO,MAAM,iBAAiB,aAAa,CAAC;AAC5C,eAAO,MAAM,wBAAwB,iBAAiB,CAAC;AAEvD;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,kBAAkB,EAOvD,CAAC;AA2OF,uFAAuF;AACvF,eAAO,MAAM,aAAa,sCAA4D,CAAC;AAEvF,2FAA2F;AAC3F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEvE;AAED,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEpE;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAQ/F;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAE5E;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAE3E;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,sBAAsB,EAAE,CAQvF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,qFAAqF;AACrF,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAEhG;AAED,kFAAkF;AAClF,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAIjG;AAYD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAerF;AAED,+EAA+E;AAC/E,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAAqC,CAAC;AAEvF,gFAAgF;AAChF,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAEvE;AAED,0EAA0E;AAC1E,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,CAEtE"}