@punica/editor 1.8.1 → 1.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@punica/editor",
-  "version": "1.8.1",
+  "version": "1.9.0",
   "description": "Punica Editor",
   "private": false,
   "type": "module",

package/types/punica.module.kernel.llm.d.ts

@@ -38,6 +38,27 @@ declare module 'punica' {
          * When provided, auto-selection can use or extend this list.
          */
         expertModelIds?: string[];
+        /**
+         * Ordered provider chain for this instruction class: the first entry
+         * is the primary target, the rest are fallbacks tried in order when an
+         * attempt fails.
+         *
+         * This is what lets a cheap local core answer a routine class while an
+         * expensive remote one stands behind it. Distinct from
+         * `expertModelId`/`expertModelIds`, which pick MULTIPLE experts to
+         * answer the SAME high-risk call concurrently — that is redundancy for
+         * quality, this is substitution on failure.
+         *
+         * Absent = fall back to the host-registered default chain
+         * (`setDefaultProviderChainResolver`), and absent that, to the
+         * substrate's existing single-model routing.
+         */
+        providerChain?: runtime.ProviderSpec[];
+        /**
+         * How failure signals advance `providerChain`. Absent = the substrate
+         * defaults (`error`/`timeout` stop, `rateLimit` advances).
+         */
+        fallbackPolicy?: runtime.FallbackPolicy;
         /**
          * Unified capability definition for LLM consumption.
          * If not provided, can be auto-generated from InstructionClass fields.
@@ -247,6 +268,24 @@ declare module 'punica' {
           filterActiveOnly?: boolean
         ): InstructionClassSummary[];
 
+        /**
+         * Inject the default provider chain — the one used by instruction
+         * classes that carry no `providerChain` of their own.
+         *
+         * The kernel must not know what an "AI core" is, where the user's
+         * models are configured, or which of them is active: all of that is
+         * product/host territory. So the chain is resolved through an injected
+         * function, exactly as `registerProductOriginResolver` handles the
+         * product → origin mapping. No resolver registered = no default chain,
+         * and routing behaves as it did before chains existed.
+         *
+         * The resolver is consulted per invocation (not cached), so activating
+         * a different core takes effect on the next call.
+         */
+        setDefaultProviderChainResolver(
+          resolver: (() => runtime.ProviderSpec[] | undefined) | undefined
+        ): void;
+
         /**
          * Invoke LLM using an instruction class.
          *

package/types/punica.module.runtime.llm.d.ts

@@ -451,6 +451,19 @@ declare module 'punica' {
         sourcePath: string;
         fileName?: string;
       }): Promise<void>;
+      /**
+       * Record an existing model file WITHOUT copying it.
+       *
+       * `importModelFile` copies the weights into host-owned storage, which
+       * duplicates a multi-gigabyte file the user may already have on disk.
+       * This registers the path in place. Optional: hosts that cannot
+       * reference files outside their own storage simply omit it, and callers
+       * feature-detect before offering the choice.
+       */
+      registerModelFile?(opts: {
+        modelId: string;
+        filePath: string;
+      }): Promise<void>;
       localServerStatus(): Promise<LocalLlmServerStatus>;
       startLocalServer(opts?: {
         host?: string;