@prismshadow/penguin-core 0.0.1

package/dist/model-catalog-DTu0IPjs.d.ts

@@ -0,0 +1,266 @@
+/** Model reference: a `(provider, model_id)` pair (never string-concatenated anywhere). */
+interface ModelRef {
+    provider: string;
+    /** Upstream model id (the request id sent to AgentHub unchanged). */
+    model_id: string;
+}
+/**
+ * Display form of a paired reference (shared by error messages and CLI output):
+ * `(provider=..., model_id=...)`. For display only — it isn't any storage or addressing format.
+ */
+declare function formatModelRef(ref: ModelRef): string;
+/**
+ * Pricing for a single Model: three price buckets, in USD per million tokens.
+ * Docs: /docs/configuration § "Project config".
+ */
+interface ModelPricing {
+    /** Pricing unit tag; currently only `usd_per_mtok` (USD per million tokens). */
+    unit: "usd_per_mtok";
+    cache_read: number;
+    cache_write: number;
+    output: number;
+}
+/**
+ * A single available Model entry (credential inlined, single config file).
+ * Docs: /docs/models § "The per-Project model table".
+ */
+interface ModelEntry {
+    /** provider group (stored separately from `model_id`; the pair is the entry's unique key). */
+    provider: string;
+    /** Upstream model id: the actual request id sent to AgentHub, used paired with provider for display, pricing, and stats. */
+    model_id: string;
+    context_window?: number;
+    /**
+     * AgentHub client protocol (`openai` / `claude-4-8` / `deepseek-v4` / …); defaults to being
+     * inferred by AgentHub from the request id (`model_id`). A third-party model speaking the
+     * OpenAI protocol should set this to `openai`.
+     */
+    client_type?: string;
+    /**
+     * Display name (the model page card title): only persisted when it differs from the builtin
+     * catalog (the user renamed it / a custom model); when not persisted, it's inferred from the
+     * builtin catalog by `(provider, model_id)`, falling back to displaying model_id if it can't be
+     * inferred.
+     */
+    display_name?: string;
+    /**
+     * Whether image input is supported (vision/multimodal); defaults to supported. For a model
+     * tagged `false` (e.g. DeepSeek): images from conversation input are saved to the session
+     * scratchpad and handed over as a file path spliced into the text, and the image-reading tool
+     * switches to describe_image (a vision model reads on its behalf) — the image never directly
+     * enters that session's history.
+     */
+    vision?: boolean;
+    /** Pricing info; absent means this Model's cost isn't counted. */
+    pricing?: ModelPricing;
+    /** API key (inlined credential); left empty falls back to the vendor's environment variable. */
+    api_key?: string;
+    /** Custom base URL (inlined credential); preset for gateway models. */
+    base_url?: string;
+    /** api_key's write timestamp (ISO 8601; a display field maintained by the interface layer). */
+    created_at?: string;
+}
+/**
+ * Project-level config.
+ * Docs: /docs/configuration § "Project config".
+ */
+interface ProjectConfig {
+    /** Project display name (the display name is separate from the id, shown as the id when unset). */
+    name?: string;
+    /** Paired reference to the default Model; must point to an entry in `models`. */
+    default_model?: ModelRef;
+    /**
+     * The vision model used by read_image to read on behalf of a session model (when a session
+     * model with `vision=false` reads an image, it's handed to this model to describe and the tool
+     * returns text); must point to an entry in `models` (a paired reference). Unconfigured by
+     * default — models that don't support images won't be able to read images.
+     */
+    vision_model?: ModelRef;
+    models: ModelEntry[];
+}
+/**
+ * Returns the Project's default config: every entry from the preset builtin model catalog
+ * (including context_window / pricing / vision tags and the preset base_url for gateway models,
+ * with no keys included) — the user only needs to fill in an API key as needed (left empty falls
+ * back to the vendor's environment variable).
+ */
+declare function defaultProjectConfig(): ProjectConfig;
+/**
+ * Loads the Project config; returns the default config (without writing to disk) if
+ * `.project_config.toml` doesn't exist. Returns plaintext (masking is applied at the interface
+ * layer); reports a clear error when the old format (a string reference / an entry missing
+ * provider) is read.
+ */
+declare function loadProjectConfig(root: string, projectId: string): Promise<ProjectConfig>;
+/**
+ * Renders the full text of `.project_config.toml` — the **single source of the write format
+ * site-wide** (shared by core's saveProjectConfig and the interface layer's full-table write, to
+ * avoid the same file ending up in two different formats).
+ *
+ * Paired references (default_model / vision_model) are rendered as a TOML inline table
+ * `{ provider = "...", model_id = "..." }`; `models` is always
+ * placed last, since any table header after `[[models]]` would be read as its sub-table. Unknown
+ * extension fields are kept as-is.
+ */
+declare function renderProjectConfigToml(data: Record<string, unknown>): string;
+/**
+ * Saves the Project config: writes the full table to the single config file
+ * `.project_config.toml`. The file contains secrets like api_key, so it's written to disk with
+ * mode 0600 (a hidden file blocks `ls`, not reads; mode only takes effect on creation, so chmod
+ * converges an existing file too).
+ */
+declare function saveProjectConfig(root: string, projectId: string, cfg: ProjectConfig): Promise<void>;
+/**
+ * Adds or updates a Model:
+ * - Upserts into `models`, deduplicated by the `(provider, model_id)` pair (provider may be
+ *   omitted — the builtin catalog is used to infer the upstream id's group, falling back to
+ *   custom if it can't be inferred);
+ * - If `api_key`/`base_url` are provided, they're written inline into the entry;
+ * - Set as the default Model (a paired reference) when `opts.setDefault` is true.
+ * Reads the existing config (or the default), saves after the change, and returns the updated
+ * config.
+ */
+declare function addModel(root: string, projectId: string, entry: {
+    /** provider group; inferred from the builtin catalog when omitted (`inferProviderForUpstream`, falling back to custom if it can't be inferred). */
+    provider?: string;
+    /** Upstream model id (sent to AgentHub unchanged). */
+    model_id: string;
+    context_window?: number;
+    client_type?: string;
+    /** Whether image input is supported (vision/multimodal); keeps the existing value by default (treated as supported if never set). */
+    vision?: boolean;
+    /** Price input may cover only some buckets; merged and written as a complete `ModelPricing`. */
+    pricing?: Partial<ModelPricing>;
+    api_key?: string;
+    base_url?: string;
+}, opts?: {
+    setDefault?: boolean;
+}): Promise<ProjectConfig>;
+/**
+ * Sets the default Model and saves. The target reference must exist in `models` (a reference
+ * pointing outside the config would make createSession error immediately); throws otherwise.
+ */
+declare function setDefaultModel(root: string, projectId: string, ref: ModelRef): Promise<ProjectConfig>;
+/**
+ * Sets the vision model used to read images on behalf of read_image, and saves. The target
+ * reference must exist in `models` and not be tagged `vision=false` (a model that doesn't support
+ * images can't read on someone's behalf); throws otherwise.
+ */
+declare function setVisionModel(root: string, projectId: string, ref: ModelRef): Promise<ProjectConfig>;
+/** Looks up a Model entry exactly by its `(provider, model_id)` paired reference; returns `undefined` if it doesn't exist. */
+declare function getModel(cfg: ProjectConfig, ref: ModelRef): ModelEntry | undefined;
+/**
+ * Resolves a model reference (the **single entry point for "provider omitted"**, shared by core
+ * and CLI/server — never set up a second one):
+ * - `provider` given: validated for existence by exact paired reference;
+ * - `provider` omitted: an exact-match lookup on `model_id` (no fuzzy matching of any kind) —
+ *   resolvable only when **exactly one** entry matches; 0 or multiple matches always report a
+ *   clear error (an ambiguity error lists the candidate paired references).
+ */
+declare function resolveModelRef(cfg: ProjectConfig, modelId: string, provider?: string): ModelRef;
+
+/**
+ * Built-in model catalog (single source of truth): official chat models that AgentHub can
+ * auto-route, shared by core's default config, server's initial config, and web/cli display.
+ * Data verified as of 2026-07-10.
+ * Docs: packages/docs/content/models.{zh,en}.md (site path /docs/models) documents the
+ * provider groups and credential resolution described here.
+ *
+ * Three-bucket pricing convention (USD per million tokens, matching usageToTokenCounts'
+ * token-to-bucket mapping):
+ * - cache_read: the vendor's "cache hit" price;
+ * - cache_write: the vendor's "cache write" price (e.g. Anthropic uses 1.25 x input); vendors
+ *   without a separate cache-write fee use the standard input price;
+ * - output: output price (thinking + reply).
+ * OpenAI charges extra for >272K input and Gemini 3.1 Pro for >200K input under official
+ * long-context pricing; this catalog only records the base tier (the cost center uses a
+ * single rate, so long-context usage will be underestimated).
+ *
+ * Scope: excludes deepseek-chat / deepseek-reasoner legacy aliases that AgentHub cannot
+ * auto-route (deprecated 2026-07-24), glm-5v-turbo (image input unsupported by AgentHub's GLM
+ * client), non-chat models (embedding / image generation / TTS), and Bedrock plus
+ * OpenRouter / SiliconFlow gateway mirror ids. Every model id in this catalog can be
+ * auto-routed by AgentHub via substring matching, so none set client_type; only custom
+ * OpenAI-protocol models need `client_type: "openai"`.
+ *
+ * This file imports no Node built-ins (type-only imports only), so it can be bundled directly
+ * for the browser.
+ */
+
+/** Model provider info (used for web grouping/logo and the "API key blank falls back to env var" hint). */
+interface ModelProviderInfo {
+    id: string;
+    /** Display name (brand name, shared by Chinese and English UI). */
+    label: string;
+    /** API key env var name (AgentHub reads this automatically when credential is blank). */
+    envKey: string;
+    /** base URL env var name. */
+    envBaseUrlKey: string;
+    /** Console URL for obtaining an API key (frontend links this in the group header); none for custom. */
+    apiKeyUrl?: string;
+    /** Vendor's model list / docs page URL (frontend's "add model" dialog links this as "get model id"); none for custom. */
+    modelsUrl?: string;
+    /**
+     * Gateway's OpenAI-compatible endpoint (openrouter / siliconflow): used by the frontend's
+     * "add model" dialog to prefill base URL by group; left blank for direct vendors and custom.
+     */
+    gatewayBaseUrl?: string;
+}
+/** A single built-in model's catalog entry (`modelId` is the upstream id; paired with `provider` it forms the catalog's unique key). */
+interface ModelCatalogEntry {
+    modelId: string;
+    displayName: string;
+    /** Provider id (one of MODEL_PROVIDERS). */
+    provider: string;
+    contextWindow?: number;
+    pricing?: ModelPricing;
+    /** Whether image input (vision modality) is supported. */
+    supportsVision: boolean;
+    /** AgentHub client protocol: required for models whose id can't be auto-routed (e.g. OpenRouter gateway models). */
+    clientType?: string;
+    /** Preset base URL (gateway models): inlined into the model entry so the user only needs to supply an API key. */
+    baseUrl?: string;
+}
+/**
+ * Provider list (web model page groups in this order): DeepSeek first (the default model's
+ * provider), followed by the OpenRouter and SiliconFlow gateways, then Google Gemini before
+ * Anthropic; custom groups custom OpenAI-protocol models and comes last.
+ */
+declare const MODEL_PROVIDERS: ModelProviderInfo[];
+/** Built-in model catalog (clustered by provider; within each provider, ordered by capability/price, highest first). */
+declare const MODEL_CATALOG: ModelCatalogEntry[];
+/** Looks up a catalog entry by (provider, upstream id) pair (**the sole catalog-matching entry point**); returns undefined if not in the catalog. */
+declare function catalogEntryFor(provider: string, upstreamId: string): ModelCatalogEntry | undefined;
+/**
+ * Infers the provider for an upstream id from the built-in catalog (used to default
+ * `provider` on `model add`): if it matches a catalog entry, use that entry's provider
+ * (upstream ids are globally unique within the catalog); otherwise custom.
+ */
+declare function inferProviderForUpstream(upstreamId: string): string;
+/** Looks up provider info by provider id; returns undefined for an unknown id. */
+declare function providerInfo(providerId: string): ModelProviderInfo | undefined;
+/** Env var fallback for a single model (the var names AgentHub's client actually reads when api_key / base_url is blank). */
+interface ModelEnvInfo {
+    envKey: string;
+    envBaseUrlKey: string;
+}
+/**
+ * Resolves the env var fallback for a model: mirrors AgentHub's
+ * AutoLLMClient routing rules (verified against agenthub v0.3.3 autoClient.ts) - an explicit
+ * client_type takes priority, otherwise routes to a client by lowercase substring match on
+ * model_id, returning the var pair that client reads; branch order matches AutoLLMClient.
+ * Returns undefined on no match (AgentHub will reject that id: it needs an explicit
+ * client_type, or should be added under custom / a self-built group via the OpenAI protocol).
+ */
+declare function resolveModelEnv(modelId: string, clientType?: string): ModelEnvInfo | undefined;
+/**
+ * Catalog -> preset ModelEntry list (shared by defaultProjectConfig and the server's initial
+ * config, avoiding duplicate hand-written copies). `provider` and `model_id` are persisted as
+ * separate fields (`model_id` is the plain upstream id); models whose upstream id can be
+ * auto-routed by AgentHub leave client_type unset; gateway models (OpenRouter / SiliconFlow)
+ * explicitly set client_type=openai and inline a preset base_url (no secrets included, so the
+ * user only needs to supply an API key).
+ */
+declare function presetModelEntries(): ModelEntry[];
+
+export { MODEL_CATALOG as M, type ProjectConfig as P, MODEL_PROVIDERS as a, type ModelCatalogEntry as b, type ModelEntry as c, type ModelEnvInfo as d, type ModelPricing as e, type ModelProviderInfo as f, type ModelRef as g, addModel as h, catalogEntryFor as i, defaultProjectConfig as j, formatModelRef as k, getModel as l, inferProviderForUpstream as m, loadProjectConfig as n, providerInfo as o, presetModelEntries as p, resolveModelEnv as q, renderProjectConfigToml as r, resolveModelRef as s, saveProjectConfig as t, setDefaultModel as u, setVisionModel as v };

package/dist/omnimessage/index.d.ts

@@ -0,0 +1,110 @@
+import { O as OmniMessage, f as AbortPayload, b as TokenCounts, A as ApprovalDecision, g as ApprovalDecisionPayload, S as StopReason, D as TextPayload, j as CompactionReason, C as CompactionMode, h as CompactionBeginPayload, i as CompactionEndPayload, I as ImageUrlPayload, y as Role, m as InlineDataPayload, n as InlineThinkingPayload, z as StreamEventType, t as PartialTextPayload, u as PartialThinkingPayload, w as PartialToolCallPayload, v as PartialToolCallOutputPayload, R as RequestBeginPayload, x as RequestEndPayload, e as SessionMetaPayload, d as SessionMetaMessage, B as SubagentPayload, F as ThinkingPayload, G as TokenUsagePayload, a as ToolCallPayload, H as ToolCallOutputPayload, M as MessageOrigin } from '../types-D6FERSdT.js';
+export { c as CompleteModelMessage, k as CompleteModelPayload, E as EventMessage, l as EventPayload, o as ModelMessage, p as ModelPayload, q as OmniMessageType, r as OmniPayload, P as PartialModelMessage, s as PartialModelPayload, T as ToolDefinition, J as isCompleteModelMessage, K as isEventMessage, L as isModelMessage, N as isPartialPayload, Q as isSessionMeta } from '../types-D6FERSdT.js';
+
+/**
+ * OmniMessage builders. All modules create messages exclusively through these builders, avoiding
+ * ad hoc protocol structures scattered across the codebase.
+ * Every builder writes an ISO 8601 UTC timestamp.
+ * Docs: /docs/omni-message § "Builders and guards".
+ */
+
+declare function sessionMeta(payload: SessionMetaPayload): SessionMetaMessage;
+/**
+ * Provider fidelity fields: kept as-is and restored verbatim on replay.
+ * Builder convention: positional-argument-style builders carry these in a trailing `fidelity`
+ * object (narrowed via Pick per payload type — e.g. thinking only has signature); object-argument-
+ * style builders (toolCall) flatten `fidelity` fields into the parameter object alongside
+ * `stopReason`, mirroring the payload structure directly.
+ */
+interface FidelityFields {
+    phase?: string | null;
+    signature?: string;
+}
+declare function textMessage(role: Role, text: string, stopReason?: StopReason, fidelity?: FidelityFields): OmniMessage<TextPayload>;
+declare const userText: (text: string) => OmniMessage<TextPayload>;
+declare const assistantText: (text: string, stopReason?: StopReason, fidelity?: FidelityFields) => OmniMessage<TextPayload>;
+declare function imageUrlMessage(imageUrl: string): OmniMessage<ImageUrlPayload>;
+declare function inlineData(role: Role, data: string, mimeType: string, fidelity?: Pick<FidelityFields, "signature">): OmniMessage<InlineDataPayload>;
+declare function thinkingMessage(thinking: string, stopReason?: StopReason, fidelity?: Pick<FidelityFields, "signature">): OmniMessage<ThinkingPayload>;
+declare function inlineThinking(data: string, mimeType: string, fidelity?: Pick<FidelityFields, "signature">): OmniMessage<InlineThinkingPayload>;
+declare function toolCall(args: {
+    name: string;
+    arguments: string;
+    toolCallId: string;
+    stopReason?: StopReason;
+    signature?: string;
+}): OmniMessage<ToolCallPayload>;
+declare function toolCallOutput(args: {
+    output: string;
+    toolCallId: string;
+    stopReason?: StopReason;
+    /** Images carried by the tool output (array of data URLs); images aren't incremental — a single delta carries the whole set in the streaming path, and the complete message carries them too. */
+    images?: string[];
+}): OmniMessage<ToolCallOutputPayload>;
+declare function partialText(eventType: StreamEventType, text?: string, stopReason?: StopReason): OmniMessage<PartialTextPayload>;
+declare function partialThinking(eventType: StreamEventType, thinking?: string, stopReason?: StopReason): OmniMessage<PartialThinkingPayload>;
+declare function partialToolCall(args: {
+    eventType: StreamEventType;
+    name: string;
+    arguments?: string;
+    toolCallId: string;
+    stopReason?: StopReason;
+}): OmniMessage<PartialToolCallPayload>;
+declare function partialToolCallOutput(args: {
+    eventType: StreamEventType;
+    output?: string;
+    toolCallId: string;
+    stopReason?: StopReason;
+    /** Images carried by the tool output (array of data URLs); images aren't incremental — a single delta carries the whole set. */
+    images?: string[];
+}): OmniMessage<PartialToolCallOutputPayload>;
+declare function approvalDecision(decision: ApprovalDecision, toolCallId: string): OmniMessage<ApprovalDecisionPayload>;
+declare function abortEvent(reason?: string | null): OmniMessage<AbortPayload>;
+/** request begin event: marks the start of one LLM Request. */
+declare function requestBegin(): OmniMessage<RequestBeginPayload>;
+/** request end event: carries the terminal state (`completed` means this turn was already committed to AgentHub). */
+declare function requestEnd(status: StopReason): OmniMessage<RequestEndPayload>;
+/** compaction begin event: carries the trigger reason, mode, current context usage, and cumulative Session turn count. */
+declare function compactionBegin(args: {
+    reason: CompactionReason;
+    mode: CompactionMode;
+    context: number;
+    turns: number;
+}): OmniMessage<CompactionBeginPayload>;
+/** compaction end event: carries the compaction result (non-`completed` means compaction was abandoned and the original context is kept). */
+declare function compactionEnd(args: {
+    reason: CompactionReason;
+    mode: CompactionMode;
+    status: StopReason;
+}): OmniMessage<CompactionEndPayload>;
+/** subagent derivation pointer event: records only the direct child session's Session id (written to the parent Trace by context_engine). */
+declare function subagentEvent(sessionId: string): OmniMessage<SubagentPayload>;
+declare function emptyTokenCounts(): TokenCounts;
+declare function tokenUsage(session: TokenCounts, request: TokenCounts): OmniMessage<TokenUsagePayload>;
+/** Adds two sets of Token counts together, used to maintain cumulative Session usage. */
+declare function addTokenCounts(a: TokenCounts, b: TokenCounts): TokenCounts;
+/**
+ * Marks a message with a nested-origin tag: prepends one hop (a child Session id) to the front
+ * of `origin`, outer-to-inner.
+ * Used by host tools (e.g. run_subagent) when forwarding child-session messages; an absent
+ * `origin` means the message comes from the main Session.
+ */
+declare function withOrigin<M extends OmniMessage>(msg: M, sessionId: MessageOrigin): M;
+
+/**
+ * Stateful aggregator. Pushed one message at a time via `push`:
+ *   - complete / event / session_meta messages are returned unchanged;
+ *   - `partial_*` messages accumulate into an internal fragment, producing a complete message
+ *     when `event_type === "stop"`;
+ *   - `flush` forcibly emits any fragments that haven't yet received a stop.
+ */
+declare class PartialAggregator {
+    private open;
+    push(msg: OmniMessage): OmniMessage[];
+    /** Finalizes: emits all still-open fragments (in the order they were opened). */
+    flush(): OmniMessage[];
+}
+/** One-shot aggregation: keeps non-partial messages in their original order, collapsing partial ones into complete messages. */
+declare function aggregateAll(messages: OmniMessage[]): OmniMessage[];
+
+export { AbortPayload, ApprovalDecision, ApprovalDecisionPayload, CompactionBeginPayload, CompactionEndPayload, CompactionMode, CompactionReason, type FidelityFields, ImageUrlPayload, InlineDataPayload, InlineThinkingPayload, MessageOrigin, OmniMessage, PartialAggregator, PartialTextPayload, PartialThinkingPayload, PartialToolCallOutputPayload, PartialToolCallPayload, RequestBeginPayload, RequestEndPayload, Role, SessionMetaMessage, SessionMetaPayload, StopReason, StreamEventType, SubagentPayload, TextPayload, ThinkingPayload, TokenCounts, TokenUsagePayload, ToolCallOutputPayload, ToolCallPayload, abortEvent, addTokenCounts, aggregateAll, approvalDecision, assistantText, compactionBegin, compactionEnd, emptyTokenCounts, imageUrlMessage, inlineData, inlineThinking, partialText, partialThinking, partialToolCall, partialToolCallOutput, requestBegin, requestEnd, sessionMeta, subagentEvent, textMessage, thinkingMessage, tokenUsage, toolCall, toolCallOutput, userText, withOrigin };

package/dist/omnimessage/index.js

@@ -0,0 +1,69 @@
+import {
+  PartialAggregator,
+  abortEvent,
+  addTokenCounts,
+  aggregateAll,
+  approvalDecision,
+  assistantText,
+  compactionBegin,
+  compactionEnd,
+  emptyTokenCounts,
+  imageUrlMessage,
+  inlineData,
+  inlineThinking,
+  isCompleteModelMessage,
+  isEventMessage,
+  isModelMessage,
+  isPartialPayload,
+  isSessionMeta,
+  partialText,
+  partialThinking,
+  partialToolCall,
+  partialToolCallOutput,
+  requestBegin,
+  requestEnd,
+  sessionMeta,
+  subagentEvent,
+  textMessage,
+  thinkingMessage,
+  tokenUsage,
+  toolCall,
+  toolCallOutput,
+  userText,
+  withOrigin
+} from "../chunk-JC6SC6KF.js";
+export {
+  PartialAggregator,
+  abortEvent,
+  addTokenCounts,
+  aggregateAll,
+  approvalDecision,
+  assistantText,
+  compactionBegin,
+  compactionEnd,
+  emptyTokenCounts,
+  imageUrlMessage,
+  inlineData,
+  inlineThinking,
+  isCompleteModelMessage,
+  isEventMessage,
+  isModelMessage,
+  isPartialPayload,
+  isSessionMeta,
+  partialText,
+  partialThinking,
+  partialToolCall,
+  partialToolCallOutput,
+  requestBegin,
+  requestEnd,
+  sessionMeta,
+  subagentEvent,
+  textMessage,
+  thinkingMessage,
+  tokenUsage,
+  toolCall,
+  toolCallOutput,
+  userText,
+  withOrigin
+};
+//# sourceMappingURL=index.js.map

package/dist/omnimessage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/state/model-catalog.d.ts

@@ -0,0 +1 @@
+export { M as MODEL_CATALOG, a as MODEL_PROVIDERS, b as ModelCatalogEntry, d as ModelEnvInfo, f as ModelProviderInfo, i as catalogEntryFor, m as inferProviderForUpstream, p as presetModelEntries, o as providerInfo, q as resolveModelEnv } from '../model-catalog-DTu0IPjs.js';

package/dist/state/model-catalog.js

@@ -0,0 +1,19 @@
+import {
+  MODEL_CATALOG,
+  MODEL_PROVIDERS,
+  catalogEntryFor,
+  inferProviderForUpstream,
+  presetModelEntries,
+  providerInfo,
+  resolveModelEnv
+} from "../chunk-FX4CCIN7.js";
+export {
+  MODEL_CATALOG,
+  MODEL_PROVIDERS,
+  catalogEntryFor,
+  inferProviderForUpstream,
+  presetModelEntries,
+  providerInfo,
+  resolveModelEnv
+};
+//# sourceMappingURL=model-catalog.js.map

package/dist/state/model-catalog.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}