@kaoruisaac/pedelec 0.3.3 → 0.3.5

package/README.md

@@ -90,6 +90,66 @@ npm install ../path/to/pedelec/sdk
 
 ---
 
+## Deno Modules
+
+Vite applications can package local or installed JavaScript/TypeScript libraries for Agent-authored `pedelec-deno` scripts.
+
+### Setup
+
+```ts
+// vite.config.ts
+import { defineConfig } from "vite";
+import { pedelecVitePlugin } from "@kaoruisaac/pedelec/vite";
+
+export default defineConfig({
+  plugins: [pedelecVitePlugin()],
+});
+```
+
+### Authoring
+
+```ts
+import { Pedelec, defineDenoModule } from "@kaoruisaac/pedelec";
+
+const pedelec = new Pedelec();
+const session = await pedelec.createSession({
+  skills: {
+    guidance: "Use sprite-tools for sprite authoring tasks.",
+    tools: [],
+    denoModules: [
+      defineDenoModule({
+        name: "sprite-tools",
+        description: "Sprite authoring and preview utilities.",
+        entry: "./agent/sprite-tools.ts",
+        usage: `import { previewActorSource } from "sprite-tools";`,
+        preferStdinExecution: true,
+      }),
+    ],
+  },
+});
+```
+
+For an installed package, use its package specifier as the build-time entry:
+
+```ts
+defineDenoModule({
+  name: "gsap",
+  description: "Animation utilities.",
+  entry: "gsap",
+  usage: `import { gsap } from "gsap";`,
+});
+```
+
+`entry` is resolved by Vite during build/dev and is never a Desktop filesystem instruction. The plugin bundles normal third-party runtime dependencies locally and generates the public `index.d.ts` declarations automatically. Node built-ins may be imported with either canonical `node:` specifiers or legacy bare specifiers; the prepared artifact preserves them as canonical `node:` imports for Deno's Node compatibility layer. This does not change the sandbox: runtime npm, JSR, network fetching, and filesystem access outside the permitted workspace remain unavailable.
+
+The generated declaration describes the module's Agent-facing API, so implementation-only dependency types are omitted. Module-owned types are supported; packages that expose dependency-owned or Node-specific external types directly in their public API are not guaranteed to produce a standalone declaration in V1. `name` is the Agent import specifier, and `usage` is required common-case guidance. `createSession()` transfers the prepared artifact automatically; a session keeps an immutable module snapshot, and `session.end()`/`session.resume()` reuse it while Core still knows the thread.
+
+Deno Modules are imported inside JavaScript/TypeScript run with `pedelec-deno`. They are different from `skills.tools`, whose browser/App RPC capabilities use `pedelec-cli` tool-spec and tool-call commands.
+
+Set the optional `preferStdinExecution: true` when short scripts primarily use a module and should be steered toward stdin execution. Host Context then adds that module's concrete `runCommandTemplate` (`@'\n<typescript-source>\n'@ | pedelec-deno --thread-id <thread-id> run -`), so the Agent only needs to replace the TypeScript source placeholder instead of deciding how to serialize stdin. This is a preference, not a restriction: file-backed execution remains valid, and omitting the field or setting it to `false` preserves the default behavior. It does not change bundling, artifact contents, or runtime permissions.
+
+---
+
 ## Minimal Example
 
 ```ts
@@ -246,7 +306,7 @@ if (availability.available) startUi();
 
 An unavailable extension may be disconnected rather than absent. `desktop.launchAttempted` means the settings probe was sent, not that Desktop was confirmed to have launched. Invalid settings responses also count as Desktop unavailable in this probe.
 
-### Selecting Provider and Effort
+### Selecting Provider, Model, and Effort
 
 ```ts
 const session = await pedelec.createSession({
@@ -258,7 +318,28 @@ const session = await pedelec.createSession({
 const defaultSession = await pedelec.createSession({ effortLevel: "low" });
 ```
 
-The SDK uses the provider-independent effort levels `default`, `low`, and `high`. An omitted level means `default`. Desktop users map each provider's profiles to concrete model and native effort arguments; that mapping is not exposed through the SDK.
+The SDK supports two mutually exclusive session configuration modes. In Desktop profile mode, `effortLevel` selects the complete Desktop profile, including its configured model and native effort arguments. An omitted level means `default`:
+
+```ts
+const profileSession = await pedelec.createSession({
+  provider: "codex",
+  effortLevel: "high",
+});
+```
+
+In explicit model mode, `model` selects the provider-native model directly and does not read or inherit any Desktop profile. The optional `effort` is provider-native and uses `low`, `medium`, `high`, `xhigh`, or `max`:
+
+```ts
+const modelSession = await pedelec.createSession({
+  provider: "codex",
+  model: "gpt-x",
+  effort: "max",
+});
+```
+
+Model-only requests are valid and use the provider's default effort behavior. `effort` requires `model`; `model` cannot be combined with `effortLevel`. The SDK does not expose or maintain a model catalog, and it does not translate the identifier into provider CLI flags. Model validity, effort support, and account entitlement remain provider-dependent, so an invalid or unavailable configuration may fail when the provider starts.
+
+Explicit model requests require an `explicitModelConfigApplied` acknowledgment from Core before the SDK exposes the session or starts Deno Module setup. If the connected Extension/Desktop is too old to provide that acknowledgment, the SDK aborts the newly created setup and reports a compatibility error instead of silently using a different configuration.
 
 Currently supported provider codes in the SDK:
 
@@ -271,6 +352,6 @@ Currently supported provider codes in the SDK:
 | Claude Code | `claude` |
 | Ollama | `ollama` |
 
-Ollama sessions are executed by the bundled `pedelec-agent`. The selected Ollama effort profile must contain a model in Desktop Settings; otherwise Core returns `MODEL_REQUIRED`. Low and high profiles are optional, but there is no fallback between profiles.
+Ollama sessions are executed by the bundled `pedelec-agent`. In profile mode, the selected Ollama effort profile must contain a model; otherwise Core returns `MODEL_REQUIRED`. In explicit model mode, `{ model }` supplies the model directly. Ollama currently does not accept an explicit `effort`. Low and high profiles are optional, but there is no fallback between profiles.
 
 `getSettings()` returns only `{ defaultProvider }`. It never exposes provider settings, effort arguments, credentials, or model names.

package/dist/deno-module-internal.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Browser-safe private interop shared by the root SDK entry and the Vite
+ * build-time plugin.  This file is intentionally not re-exported from the
+ * package root: application code authors the small DenoModuleDefinition only.
+ */
+export declare const PREPARED_DENO_MODULE_ARTIFACT_PROPERTY = "__pedelecArtifact";
+export type PreparedDenoModuleArtifact = {
+    readonly format: "esm";
+    readonly runtimeSource: string;
+    readonly typesSource: string;
+    readonly contentHash?: string;
+};
+export declare function getPreparedDenoModuleArtifact(value: unknown): PreparedDenoModuleArtifact | null;
+/**
+ * Keep this deliberately narrower than arbitrary URL/path syntax.  Core has
+ * the corresponding contract in Rust; both sides accept ordinary bare and
+ * scoped package-like specifiers only.
+ */
+export declare function isValidDenoModuleName(value: unknown): value is string;

package/dist/deno-module-internal.js

@@ -0,0 +1,49 @@
+/**
+ * Browser-safe private interop shared by the root SDK entry and the Vite
+ * build-time plugin.  This file is intentionally not re-exported from the
+ * package root: application code authors the small DenoModuleDefinition only.
+ */
+export const PREPARED_DENO_MODULE_ARTIFACT_PROPERTY = "__pedelecArtifact";
+export function getPreparedDenoModuleArtifact(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const artifact = value[PREPARED_DENO_MODULE_ARTIFACT_PROPERTY];
+    if (!artifact || typeof artifact !== "object" || Array.isArray(artifact))
+        return null;
+    const candidate = artifact;
+    if (candidate.format !== "esm" ||
+        typeof candidate.runtimeSource !== "string" ||
+        candidate.runtimeSource.trim().length === 0 ||
+        typeof candidate.typesSource !== "string" ||
+        candidate.typesSource.trim().length === 0) {
+        return null;
+    }
+    return {
+        format: "esm",
+        runtimeSource: candidate.runtimeSource,
+        typesSource: candidate.typesSource,
+        ...(typeof candidate.contentHash === "string" ? { contentHash: candidate.contentHash } : {}),
+    };
+}
+const DENO_MODULE_SEGMENT_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+/**
+ * Keep this deliberately narrower than arbitrary URL/path syntax.  Core has
+ * the corresponding contract in Rust; both sides accept ordinary bare and
+ * scoped package-like specifiers only.
+ */
+export function isValidDenoModuleName(value) {
+    if (typeof value !== "string" || value.length === 0 || value.trim() !== value)
+        return false;
+    if (value === "." || value === ".." || value.includes("\\") || value.includes("\0"))
+        return false;
+    if (value.includes(":") || value.startsWith("/") || value.endsWith("/"))
+        return false;
+    const parts = value.split("/");
+    if (parts.length === 1)
+        return DENO_MODULE_SEGMENT_PATTERN.test(parts[0]);
+    if (parts.length !== 2 || !parts[0].startsWith("@") || parts[0].length === 1)
+        return false;
+    const scope = parts[0].slice(1);
+    const packageName = parts[1];
+    return DENO_MODULE_SEGMENT_PATTERN.test(scope) && DENO_MODULE_SEGMENT_PATTERN.test(packageName);
+}

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export type PedelecOptions = {
 };
 export type ProviderCode = "codex" | "antigravity" | "opencode" | "cursor" | "claude" | "ollama";
 export type EffortLevel = "default" | "low" | "high";
+export type Effort = "low" | "medium" | "high" | "xhigh" | "max";
 export type JsonPrimitive = string | number | boolean | null;
 export type JsonValue = JsonPrimitive | JsonValue[] | {
     [key: string]: JsonValue;
@@ -15,6 +16,13 @@ export type Asset = {
     sizeBytes: number;
     modifiedAt: number;
 };
+export type DenoModuleDefinition<TName extends string = string> = {
+    name: TName;
+    description: string;
+    entry: string;
+    usage: string;
+    preferStdinExecution?: boolean;
+};
 export type ToolArgsSchemaMeta<TDefault extends JsonValue = JsonValue> = {
     description?: string;
     default?: TDefault;
@@ -71,6 +79,7 @@ export type ToolDefinition<TArgs = unknown, TResult = unknown, TName extends str
 export type SkillsInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
     guidance: string;
     tools: TTools;
+    denoModules?: readonly DenoModuleDefinition[];
 };
 export type ToolNameOf<TTools extends readonly ToolDefinition[]> = Extract<TTools[number]["name"], string>;
 export type SerializableToolManifest = {
@@ -79,9 +88,16 @@ export type SerializableToolManifest = {
     argsSchema: ToolArgsSchema;
     timeoutMs?: number;
 };
+type SerializableDenoModuleManifest = {
+    name: string;
+    description: string;
+    usage: string;
+    preferStdinExecution?: boolean;
+};
 export type SerializableSkillsManifest = {
     guidance: string;
     tools: SerializableToolManifest[];
+    denoModules?: SerializableDenoModuleManifest[];
 };
 export type CreateSessionWorkspaceInput = {
     path: string;
@@ -91,21 +107,26 @@ export interface WorkspaceFolderPickerResult {
     isEmptyFolder: boolean;
     hasWorkspaceConfig: boolean;
 }
-type CreateSessionInputWithProvider<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
-    provider: ProviderCode;
-    effortLevel?: EffortLevel;
+type CreateSessionSharedInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
     skills?: SkillsInput<TTools>;
     workspace?: CreateSessionWorkspaceInput;
     autoEndOnDisconnect?: boolean;
 };
-type CreateSessionInputWithDefaults<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
-    provider?: undefined;
+type ProfileSessionConfiguration = {
+    model?: never;
+    effort?: never;
     effortLevel?: EffortLevel;
-    skills?: SkillsInput<TTools>;
-    workspace?: CreateSessionWorkspaceInput;
-    autoEndOnDisconnect?: boolean;
 };
-export type CreateSessionInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = CreateSessionInputWithProvider<TTools> | CreateSessionInputWithDefaults<TTools>;
+type ExplicitModelSessionConfiguration = {
+    model: string;
+    effort?: Effort;
+    effortLevel?: never;
+};
+export type CreateSessionInput<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = (CreateSessionSharedInput<TTools> & {
+    provider?: ProviderCode;
+} & ProfileSessionConfiguration) | (CreateSessionSharedInput<TTools> & {
+    provider?: ProviderCode;
+} & ExplicitModelSessionConfiguration);
 export type ProviderInfo = {
     name: string;
     code: ProviderCode;
@@ -287,6 +308,7 @@ type ErrorHandler = (error: PedelecError, ctx: ErrorEventContext) => void;
 type StatusHandler = (status: PedelecSessionStatus, ctx: StatusEventContext) => void;
 type EndedHandler = (ctx: EndedEventContext) => void;
 export declare function defineTool<TArgs = unknown, TResult = unknown, const TName extends string = string>(tool: ToolDefinition<TArgs, TResult, TName>): ToolDefinition<TArgs, TResult, TName>;
+export declare function defineDenoModule<const TName extends string>(module: DenoModuleDefinition<TName>): DenoModuleDefinition<TName>;
 export declare class Pedelec {
     private readonly pageWindow;
     private readonly channelId;
@@ -301,6 +323,9 @@ export declare class Pedelec {
     constructor(options?: PedelecOptions);
     createSession(): Promise<PedelecSession<string>>;
     createSession<const TTools extends readonly ToolDefinition[]>(input: CreateSessionInput<TTools>): Promise<PedelecSession<ToolNameOf<TTools>>>;
+    private uploadDenoModuleArtifact;
+    private abortSessionSetup;
+    private completeSessionSetup;
     workspaceFolderPicker(): Promise<WorkspaceFolderPickerResult | null>;
     listProviders(): Promise<ProviderInfo[]>;
     getSettings(): Promise<PedelecSettings>;

package/dist/index.js

@@ -1,4 +1,5 @@
 import { PEDELEC_EXTENSION_ID } from "./extension-id.js";
+import { getPreparedDenoModuleArtifact, isValidDenoModuleName, } from "./deno-module-internal.js";
 import { SDK_VERSION } from "./version.generated.js";
 const SDK_EXTERNAL_PORT_NAME = "pedelec-sdk-external";
 const PAGE_ACTIVITY_MESSAGE_TYPE = "page_activity";
@@ -35,10 +36,13 @@ const TOOL_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
 export function defineTool(tool) {
     return tool;
 }
+export function defineDenoModule(module) {
+    return module;
+}
 function normalizeSkillsInput(value) {
     const handlers = new Map();
     if (value === undefined)
-        return { handlers };
+        return { handlers, denoModules: [] };
     if (!value || typeof value !== "object" || Array.isArray(value)) {
         throw makeError("INVALID_INPUT", "skills must be an object");
     }
@@ -49,7 +53,11 @@ function normalizeSkillsInput(value) {
     if (!Array.isArray(skills.tools)) {
         throw makeError("INVALID_INPUT", "skills.tools must be an array");
     }
+    if (skills.denoModules !== undefined && !Array.isArray(skills.denoModules)) {
+        throw makeError("INVALID_INPUT", "skills.denoModules must be an array");
+    }
     const seen = new Set();
+    const seenDenoModuleNames = new Set();
     const tools = skills.tools.map((tool, index) => {
         if (!tool || typeof tool !== "object" || Array.isArray(tool)) {
             throw makeError("INVALID_INPUT", "skills.tools entries must be objects", { index });
@@ -91,12 +99,77 @@ function normalizeSkillsInput(value) {
             ...(rawTool.timeoutMs === undefined ? {} : { timeoutMs: rawTool.timeoutMs }),
         };
     });
+    const denoModules = (skills.denoModules ?? []).map((module, index) => {
+        if (!module || typeof module !== "object" || Array.isArray(module)) {
+            throw makeError("INVALID_INPUT", "skills.denoModules entries must be objects", { index });
+        }
+        const rawModule = module;
+        if (!isValidDenoModuleName(rawModule.name)) {
+            throw makeError("INVALID_INPUT", "Deno Module name is invalid", {
+                index,
+                moduleName: rawModule.name,
+            });
+        }
+        if (seenDenoModuleNames.has(rawModule.name)) {
+            throw makeError("INVALID_INPUT", "duplicate Deno Module name", {
+                moduleName: rawModule.name,
+            });
+        }
+        seenDenoModuleNames.add(rawModule.name);
+        if (typeof rawModule.description !== "string" || rawModule.description.trim().length === 0) {
+            throw makeError("INVALID_INPUT", "Deno Module description must be a non-empty string", {
+                moduleName: rawModule.name,
+            });
+        }
+        if (typeof rawModule.usage !== "string" || rawModule.usage.trim().length === 0) {
+            throw makeError("INVALID_INPUT", "Deno Module usage must be a non-empty string", {
+                moduleName: rawModule.name,
+            });
+        }
+        if (rawModule.entry !== undefined &&
+            (typeof rawModule.entry !== "string" || rawModule.entry.trim().length === 0)) {
+            throw makeError("INVALID_INPUT", "Deno Module entry must be a non-empty string", {
+                moduleName: rawModule.name,
+            });
+        }
+        if (rawModule.preferStdinExecution !== undefined && typeof rawModule.preferStdinExecution !== "boolean") {
+            throw makeError("INVALID_INPUT", "Deno Module preferStdinExecution must be a boolean", {
+                moduleName: rawModule.name,
+            });
+        }
+        const artifact = getPreparedDenoModuleArtifact(module);
+        if (!artifact) {
+            throw makeError("INVALID_INPUT", `Deno module "${rawModule.name}" was not prepared. Configure pedelecVitePlugin() in the Vite project.`, { moduleName: rawModule.name });
+        }
+        return {
+            name: rawModule.name,
+            description: rawModule.description,
+            usage: rawModule.usage,
+            ...(rawModule.preferStdinExecution === true ? { preferStdinExecution: true } : {}),
+            artifact,
+        };
+    });
     return {
         manifest: {
             guidance: skills.guidance,
             tools,
+            ...(denoModules.length > 0
+                ? {
+                    denoModules: denoModules.map(({ name, description, usage, preferStdinExecution }) => ({
+                        name,
+                        description,
+                        usage,
+                        ...(preferStdinExecution === true ? { preferStdinExecution: true } : {}),
+                    })),
+                }
+                : {}),
         },
         handlers,
+        denoModules: denoModules.map(({ name, artifact }) => ({
+            name,
+            runtimeSource: artifact.runtimeSource,
+            typesSource: artifact.typesSource,
+        })),
     };
 }
 function normalizeToolArgsSchema(argsSchema, toolName) {
@@ -144,6 +217,8 @@ export class Pedelec {
         const result = await this.request("create_session", {
             input: {
                 provider: resolvedInput.provider,
+                model: resolvedInput.model,
+                effort: resolvedInput.effort,
                 effortLevel: resolvedInput.effortLevel,
                 skills: resolvedInput.skills,
                 workspace: resolvedInput.workspace,
@@ -153,8 +228,94 @@ export class Pedelec {
         if (!result.sessionId) {
             throw makeError("SDK_PROTOCOL_ERROR", "create_session response did not include sessionId");
         }
+        if (resolvedInput.model !== undefined && result.explicitModelConfigApplied !== true) {
+            const error = makeError("SDK_PROTOCOL_ERROR", "The connected Pedelec Extension/Desktop does not support explicit model configuration. Update Pedelec components and try again.", { feature: "explicitModelConfig" });
+            await this.abortSessionSetup(result.sessionId);
+            throw error;
+        }
+        try {
+            for (const module of resolvedInput.denoModules) {
+                await this.uploadDenoModuleArtifact(result.sessionId, module);
+            }
+            if (resolvedInput.denoModules.length > 0) {
+                await this.completeSessionSetup(result.sessionId);
+            }
+        }
+        catch (error) {
+            // The thread exists at this point but is not exposed through the SDK
+            // session registry yet.  Keep the setup failure as the caller-visible
+            // error even if the best-effort cleanup transport also fails.
+            await this.abortSessionSetup(result.sessionId);
+            throw normalizeError(error, "DENO_MODULE_UPLOAD_FAILED", "Deno Module setup failed");
+        }
         return this.registerSession(result.sessionId, resolvedInput.provider, resolvedInput.effortLevel, resolvedInput.inlineToolHandlers, resolvedInput.autoEndOnDisconnect);
     }
+    async uploadDenoModuleArtifact(sessionId, module) {
+        const envelope = JSON.stringify({
+            version: 1,
+            format: "esm",
+            runtimeSource: module.runtimeSource,
+            typesSource: module.typesSource,
+        });
+        const body = new Blob([envelope], { type: "application/json" });
+        const expectedSizeBytes = body.size;
+        if (expectedSizeBytes <= 0 || expectedSizeBytes > MAX_ASSET_UPLOAD_BYTES) {
+            throw makeError("DENO_MODULE_ARTIFACT_TOO_LARGE", `Deno Module "${module.name}" artifact exceeds the 100 MiB limit`, { moduleName: module.name, expectedSizeBytes, maxSizeBytes: MAX_ASSET_UPLOAD_BYTES });
+        }
+        const ticket = await this.request("create_deno_module_upload", {
+            sessionId,
+            moduleName: module.name,
+            expectedSizeBytes,
+        });
+        if (!isPlainObject(ticket) || typeof ticket.uploadUrl !== "string" || ticket.uploadUrl.length === 0 ||
+            typeof ticket.token !== "string" || ticket.token.length === 0) {
+            throw makeError("SDK_PROTOCOL_ERROR", "Deno Module upload ticket was invalid", {
+                moduleName: module.name,
+            });
+        }
+        let response;
+        try {
+            response = await fetch(ticket.uploadUrl, {
+                method: "PUT",
+                headers: {
+                    Authorization: `Bearer ${ticket.token}`,
+                    "Content-Type": "application/json",
+                },
+                body,
+                credentials: "omit",
+            });
+        }
+        catch (error) {
+            throw normalizeError(error, "DENO_MODULE_UPLOAD_FAILED", `Deno Module "${module.name}" upload failed`);
+        }
+        let payload = null;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            // The status below remains authoritative for a successful response;
+            // failed responses without JSON receive the private fallback error.
+        }
+        if (!response.ok) {
+            const errorValue = isPlainObject(payload) ? payload.error : undefined;
+            throw normalizeError(errorValue, "DENO_MODULE_UPLOAD_FAILED", `Deno Module "${module.name}" upload failed`);
+        }
+        if (!isPlainObject(payload) || payload.ready !== true) {
+            throw makeError("DENO_MODULE_SETUP_FAILED", `Deno Module "${module.name}" was not materialized`, { moduleName: module.name });
+        }
+    }
+    async abortSessionSetup(sessionId) {
+        try {
+            await this.request("abort_session_setup", { sessionId });
+        }
+        catch {
+            // Rollback is deliberately best effort.  The original setup/upload
+            // error is the only error exposed by createSession().
+        }
+    }
+    async completeSessionSetup(sessionId) {
+        await this.request("complete_session_setup", { sessionId });
+    }
     async workspaceFolderPicker() {
         const result = await this.requestWithOptions("pick_workspace_folder", {}, { timeoutMs: null });
         return normalizeWorkspaceFolderPickerResponse(result);
@@ -345,8 +506,31 @@ export class Pedelec {
         const raw = (input ?? {});
         const provider = typeof raw.provider === "string" ? raw.provider.trim() : "";
         const hasProvider = provider.length > 0;
-        if (raw.model !== undefined) {
-            throw makeError("INVALID_INPUT", "model is no longer supported; configure provider effort profiles in Desktop Settings");
+        const model = normalizeCreateSessionModelInput(raw.model);
+        if (model !== undefined) {
+            if (raw.effortLevel !== undefined) {
+                throw makeError("INVALID_INPUT", "effortLevel cannot be combined with model");
+            }
+            const effort = normalizeCreateSessionEffortInput(raw.effort);
+            const autoEndOnDisconnect = raw.autoEndOnDisconnect !== false;
+            const normalizedSkills = normalizeSkillsInput(raw.skills);
+            const workspace = normalizeCreateSessionWorkspaceInput(raw.workspace);
+            if (!hasProvider) {
+                return this.resolveDefaultCreateSessionInput(model, effort, undefined, normalizedSkills, workspace, autoEndOnDisconnect);
+            }
+            return {
+                provider: provider,
+                model,
+                effort,
+                skills: normalizedSkills.manifest,
+                workspace,
+                inlineToolHandlers: normalizedSkills.handlers,
+                denoModules: normalizedSkills.denoModules,
+                autoEndOnDisconnect,
+            };
+        }
+        if (raw.effort !== undefined) {
+            throw makeError("INVALID_INPUT", "effort requires model");
         }
         const effortLevel = raw.effortLevel === undefined ? "default" : raw.effortLevel;
         if (!isEffortLevel(effortLevel)) {
@@ -356,7 +540,7 @@ export class Pedelec {
         const normalizedSkills = normalizeSkillsInput(raw.skills);
         const workspace = normalizeCreateSessionWorkspaceInput(raw.workspace);
         if (!hasProvider) {
-            return this.resolveDefaultCreateSessionInput(effortLevel, normalizedSkills, workspace, autoEndOnDisconnect);
+            return this.resolveDefaultCreateSessionInput(undefined, undefined, effortLevel, normalizedSkills, workspace, autoEndOnDisconnect);
         }
         return {
             provider: provider,
@@ -364,6 +548,7 @@ export class Pedelec {
             skills: normalizedSkills.manifest,
             workspace,
             inlineToolHandlers: normalizedSkills.handlers,
+            denoModules: normalizedSkills.denoModules,
             autoEndOnDisconnect,
         };
     }
@@ -419,7 +604,7 @@ export class Pedelec {
             };
         }
     }
-    async resolveDefaultCreateSessionInput(effortLevel, normalizedSkills, workspace, autoEndOnDisconnect) {
+    async resolveDefaultCreateSessionInput(model, effort, effortLevel, normalizedSkills, workspace, autoEndOnDisconnect) {
         const settings = await this.getSettings();
         if (!settings.defaultProvider) {
             throw makeError("DEFAULT_PROVIDER_NOT_SET", "Default provider is not set. Open the Pedelec desktop app Settings page and choose a default provider.");
@@ -427,10 +612,13 @@ export class Pedelec {
         await this.assertDefaultProviderAvailable(settings.defaultProvider);
         return {
             provider: settings.defaultProvider,
+            model,
+            effort,
             effortLevel,
             skills: normalizedSkills.manifest,
             workspace,
             inlineToolHandlers: normalizedSkills.handlers,
+            denoModules: normalizedSkills.denoModules,
             autoEndOnDisconnect,
         };
     }
@@ -593,6 +781,22 @@ function normalizeCreateSessionWorkspaceInput(value) {
     }
     return { path };
 }
+function normalizeCreateSessionModelInput(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw makeError("INVALID_INPUT", "model must be a non-empty string when provided");
+    }
+    return value.trim();
+}
+function normalizeCreateSessionEffortInput(value) {
+    if (value === undefined)
+        return undefined;
+    if (!isEffort(value)) {
+        throw makeError("INVALID_INPUT", "effort must be one of low, medium, high, xhigh, or max");
+    }
+    return value;
+}
 export class PedelecSession {
     client;
     sessionId;
@@ -1399,6 +1603,9 @@ function isProviderCode(value) {
 function isEffortLevel(value) {
     return value === "default" || value === "low" || value === "high";
 }
+function isEffort(value) {
+    return value === "low" || value === "medium" || value === "high" || value === "xhigh" || value === "max";
+}
 function isPlainObject(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -1504,6 +1711,10 @@ function isDeterministicResumeError(error) {
         error.code === "THREAD_NOT_FOUND" ||
         error.code === "WORKSPACE_OPEN_FAILED" ||
         error.code === "PROVIDER_COMMAND_FAILED" ||
+        error.code === "DENO_MODULE_SETUP_INCOMPLETE" ||
+        error.code === "DENO_MODULE_SETUP_FAILED" ||
+        error.code === "DENO_MODULE_MATERIALIZATION_FAILED" ||
+        error.code === "DENO_IMPORT_MAP_INVALID" ||
         error.code === "INVALID_INPUT";
 }
 function normalizeError(err, fallbackCode, fallbackMessage) {