@d3ara1n/pi-model-roles 0.4.0 → 0.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@d3ara1n/pi-model-roles",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "type": "module",
   "description": "Model role configuration library for pi extensions — defines named model roles and resolves them to Model instances",
   "main": "src/index.ts",

package/src/api.ts

@@ -6,6 +6,7 @@
  * Exported functions provide type-safe access — consumers never touch globalThis.
  */
 
+import { complete as piAiComplete, streamSimple as piAiStreamSimple } from "@earendil-works/pi-ai";
 import type { ModelRolesAPI, ModelRolesConfig, RoleConfig, ResolvedRole } from "./types.ts";
 import { loadRolesConfig } from "./config.ts";
 import { resolveModelForRole, resolveModelForRoleAsync } from "./resolver.ts";
@@ -147,6 +148,56 @@ export function initModelRolesAPI(
         .getAvailable()
         .map((m: { provider: string; id: string }) => `${m.provider}/${m.id}`);
     },
+
+    async complete(roleName: string, context: any, options?: any): Promise<any> {
+      // Resolve model: explicit override wins, else the role's declared model
+      // (model=null transparently uses pi's current model).
+      const roleConfig = getConfig().roles[roleName] ?? { model: null };
+      const model =
+        options?.model ??
+        resolveModelForRole(roleConfig, state.modelRegistry, state.currentModel).model;
+      if (!model) {
+        throw new Error(`complete: role "${roleName}" has no available model`);
+      }
+      // Resolve auth for the model actually used (refreshes OAuth tokens).
+      const auth = await state.modelRegistry.getApiKeyAndHeaders(model);
+      if (!auth.ok) {
+        throw new Error(`complete: auth failed for ${model.provider}/${model.id}: ${auth.error}`);
+      }
+      // Forward everything except `model` to pi-ai's complete().
+      const { model: _omitModel, ...streamOptions } = options ?? {};
+      if (auth.apiKey) streamOptions.apiKey = auth.apiKey;
+      if (auth.headers) streamOptions.headers = auth.headers;
+      // Apply the role's thinking level unless the caller explicitly overrides it.
+      if (roleConfig.thinking && streamOptions.reasoningEffort === undefined) {
+        streamOptions.reasoningEffort = roleConfig.thinking;
+      }
+      return piAiComplete(model, context, streamOptions);
+    },
+
+    async streamWithRole(roleName: string, context: any, options?: any): Promise<any> {
+      const roleConfig = getConfig().roles[roleName] ?? { model: null };
+      const model =
+        options?.model ??
+        resolveModelForRole(roleConfig, state.modelRegistry, state.currentModel).model;
+      if (!model) {
+        throw new Error(`streamWithRole: role "${roleName}" has no available model`);
+      }
+      const auth = await state.modelRegistry.getApiKeyAndHeaders(model);
+      if (!auth.ok) {
+        throw new Error(
+          `streamWithRole: auth failed for ${model.provider}/${model.id}: ${auth.error}`,
+        );
+      }
+      const { model: _omitModel, ...streamOptions } = options ?? {};
+      if (auth.apiKey) streamOptions.apiKey = auth.apiKey;
+      if (auth.headers) streamOptions.headers = auth.headers;
+      // Apply the role's thinking level unless the caller explicitly overrides it.
+      if (roleConfig.thinking && streamOptions.reasoning === undefined) {
+        streamOptions.reasoning = roleConfig.thinking;
+      }
+      return piAiStreamSimple(model, context, streamOptions);
+    },
   };
 
   // Store on globalThis — survives module identity mismatches

package/src/index.ts

@@ -17,6 +17,16 @@ export type {
   ModelRolesConfig,
   ThinkingLevel,
 } from "./types.ts";
+// Re-export pi-ai types so consumers depend on model-roles alone, not pi-ai.
+export type {
+  Api,
+  AssistantMessage,
+  AssistantMessageEventStream,
+  Context,
+  Model,
+  ProviderStreamOptions,
+  SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
 
 export default function registerModelRolesExtension(pi: ExtensionAPI): void {
   pi.on("session_start", async (_event, ctx) => {

package/src/types.ts

@@ -2,6 +2,16 @@
  * Shared types for pi-model-roles.
  */
 
+import type {
+  Api,
+  AssistantMessage,
+  AssistantMessageEventStream,
+  Context,
+  Model,
+  ProviderStreamOptions,
+  SimpleStreamOptions,
+} from "@earendil-works/pi-ai";
+
 /** Thinking level configuration for a role. */
 export type ThinkingLevel = "off" | "minimal" | "low" | "medium" | "high" | "xhigh";
 
@@ -97,4 +107,51 @@ export interface ModelRolesAPI {
   getCurrentRole(modelId: string): string | undefined;
   /** List all available models from pi's model registry. Returns provider/id strings (e.g. "anthropic/claude-sonnet-4"). */
   listModels(): string[];
+
+  /**
+   * Call pi-ai's complete() with auth resolved internally from the role's model.
+   *
+   * Auth (including OAuth token refresh) is resolved for the model actually
+   * used, so callers never handle API keys or headers. The role's
+   * {@link RoleConfig.thinking} level is applied as `reasoningEffort` unless
+   * the caller sets it explicitly. No fallback, no retry, no error swallowing;
+   * throws if the role has no available model or auth resolution fails.
+   *
+   * @param roleName - Role whose model + auth + thinking to use
+   * @param context - Conversation context (systemPrompt + messages)
+   * @param options - Stream options forwarded to pi-ai's complete(). Pass
+   *   `model` to override the role's model (auth is then resolved for that
+   *   model); pass `reasoningEffort` to override the role's thinking level;
+   *   all other fields pass through unchanged.
+   */
+  complete<TApi extends Api = Api>(
+    roleName: string,
+    context: Context,
+    options?: ProviderStreamOptions & { model?: Model<TApi> },
+  ): Promise<AssistantMessage>;
+
+  /**
+   * Call pi-ai's streamSimple() with auth resolved internally from the role's model.
+   *
+   * Streaming counterpart to {@link complete}. Same auth resolution (including
+   * OAuth token refresh), same thinking-level application (role's
+   * {@link RoleConfig.thinking} → `reasoning` unless overridden), and same
+   * error semantics (throws on no model / auth failure). Returns the pi-ai
+   * event stream — iterate it for events, call `.result()` for the final
+   * AssistantMessage.
+   *
+   * Note: unlike pi-ai's synchronous `streamSimple`, this is async because auth
+   * resolution (OAuth token refresh) must complete before the stream starts.
+   *
+   * @param roleName - Role whose model + auth + thinking to use
+   * @param context - Conversation context (systemPrompt + messages)
+   * @param options - Stream options forwarded to pi-ai's streamSimple(). Pass
+   *   `model` to override the role's model; pass `reasoning` to override the
+   *   role's thinking level; all other fields pass through.
+   */
+  streamWithRole<TApi extends Api = Api>(
+    roleName: string,
+    context: Context,
+    options?: SimpleStreamOptions & { model?: Model<TApi> },
+  ): Promise<AssistantMessageEventStream>;
 }