@punica/editor 1.8.0 → 1.9.0

package/package.json

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

package/types/punica.module.extensions.api.d.ts

@@ -76,8 +76,24 @@ declare module 'punica' {
          */
         showOnStartup?: boolean;
       };
-      activityBar?: Pick<BaseView, 'id' | 'name'> &
-        Required<Pick<BaseView, 'title' | 'icon' | 'alignment'>>;
+      activityBar?: Pick<BaseView, 'id' | 'name' | 'capability'> &
+        Required<Pick<BaseView, 'title' | 'icon' | 'alignment'>> & {
+          /**
+           * Draw this item together with every other item declaring the same
+           * `group.id`: one icon, and a flyout listing the members once there
+           * is more than one. Lets a family of extensions (marketplaces,
+           * database providers, …) grow without taking a bar slot each.
+           * The group's identity lives here, in the manifests — the substrate
+           * knows only "same id, same icon". Ignored by older shells.
+           */
+          group?: {
+            id: string;
+            /** Tooltip of the group icon. First member to declare it wins. */
+            title?: string;
+            /** Group icon (raw HTML). First member to declare it wins. */
+            icon?: string;
+          };
+        };
       statusBar?: Pick<BaseView, 'id' | 'name'> &
         Required<Pick<BaseView, 'title' | 'label' | 'icon' | 'alignment'>>;
     }

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;

package/types/punica.module.shell.activityBar.d.ts

@@ -4,6 +4,20 @@ declare module 'punica' {
       type Alignment = 'primary' | 'secondary';
       type ItemType = 'normal' | 'menu';
 
+      /**
+       * Groups several activity items behind one icon. Declared per member —
+       * the substrate has no group table of its own, so what a group means
+       * (marketplaces, databases, …) stays in the manifests that opt in.
+       */
+      interface IItemGroup {
+        /** Members sharing this id are drawn as a single icon. */
+        id: string;
+        /** Tooltip of the group icon. First member to declare it wins; defaults to `id`. */
+        title?: string;
+        /** Group icon (raw HTML). First member to declare it wins; defaults to the first member's icon. */
+        icon?: string;
+      }
+
       interface IItem {
         id: string;
         name: string;
@@ -31,6 +45,14 @@ declare module 'punica' {
          * and the Capability Catalog. See `IActivityBarManager.syncContentTool`.
          */
         contentViewType?: string;
+        /**
+         * Collect this item into a group. While the group has one member the
+         * shell draws that member's own icon and click behaviour; when a
+         * second member joins, the icon becomes the group's and clicking it
+         * opens a flyout listing the members. Shells that predate grouping
+         * ignore the field and draw the item on its own, as before.
+         */
+        group?: IItemGroup;
       }
 
       interface IActivityBarManager {