@kaoruisaac/pedelec 0.3.3 → 0.3.4

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,19 @@ 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 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 profile remains the default source of both values, but an application may optionally override only the model for one session:
+
+```ts
+const specializedSession = await pedelec.createSession({
+  provider: "codex",
+  effortLevel: "high",
+  model: "gpt-x",
+});
+```
+
+`model` is an optional provider-native identifier. Omitting it preserves the existing Desktop-profile behavior; providing it does not disable `effortLevel`, replaces only the selected profile's model, and leaves its native effort arguments intact. The SDK does not expose or maintain a model catalog, and it does not translate the identifier into provider CLI flags. Model validity and account entitlement remain provider-dependent, so an invalid or unavailable model may fail when the provider starts.
+
+For an explicit model, the SDK requires an acknowledgment from Core that the override was applied before it 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 ignoring the model.
 
 Currently supported provider codes in the SDK:
 
@@ -271,6 +343,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`. The selected Ollama effort profile must contain a model unless `createSession({ model })` supplies the explicit model override; otherwise Core returns `MODEL_REQUIRED`. 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

@@ -15,6 +15,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 +78,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 +87,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;
@@ -93,6 +108,7 @@ export interface WorkspaceFolderPickerResult {
 }
 type CreateSessionInputWithProvider<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
     provider: ProviderCode;
+    model?: string;
     effortLevel?: EffortLevel;
     skills?: SkillsInput<TTools>;
     workspace?: CreateSessionWorkspaceInput;
@@ -100,6 +116,7 @@ type CreateSessionInputWithProvider<TTools extends readonly ToolDefinition[] = r
 };
 type CreateSessionInputWithDefaults<TTools extends readonly ToolDefinition[] = readonly ToolDefinition[]> = {
     provider?: undefined;
+    model?: string;
     effortLevel?: EffortLevel;
     skills?: SkillsInput<TTools>;
     workspace?: CreateSessionWorkspaceInput;
@@ -287,6 +304,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 +319,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,7 @@ export class Pedelec {
         const result = await this.request("create_session", {
             input: {
                 provider: resolvedInput.provider,
+                model: resolvedInput.model,
                 effortLevel: resolvedInput.effortLevel,
                 skills: resolvedInput.skills,
                 workspace: resolvedInput.workspace,
@@ -153,8 +227,94 @@ export class Pedelec {
         if (!result.sessionId) {
             throw makeError("SDK_PROTOCOL_ERROR", "create_session response did not include sessionId");
         }
+        if (resolvedInput.model !== undefined && result.modelOverrideApplied !== true) {
+            const error = makeError("SDK_PROTOCOL_ERROR", "The connected Pedelec Extension/Desktop does not support createSession model override. Update Pedelec components and try again.", { feature: "modelOverride" });
+            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,9 +505,7 @@ 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);
         const effortLevel = raw.effortLevel === undefined ? "default" : raw.effortLevel;
         if (!isEffortLevel(effortLevel)) {
             throw makeError("INVALID_INPUT", "effortLevel must be one of default, low, or high");
@@ -356,14 +514,16 @@ 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(model, effortLevel, normalizedSkills, workspace, autoEndOnDisconnect);
         }
         return {
             provider: provider,
+            model,
             effortLevel,
             skills: normalizedSkills.manifest,
             workspace,
             inlineToolHandlers: normalizedSkills.handlers,
+            denoModules: normalizedSkills.denoModules,
             autoEndOnDisconnect,
         };
     }
@@ -419,7 +579,7 @@ export class Pedelec {
             };
         }
     }
-    async resolveDefaultCreateSessionInput(effortLevel, normalizedSkills, workspace, autoEndOnDisconnect) {
+    async resolveDefaultCreateSessionInput(model, 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 +587,12 @@ export class Pedelec {
         await this.assertDefaultProviderAvailable(settings.defaultProvider);
         return {
             provider: settings.defaultProvider,
+            model,
             effortLevel,
             skills: normalizedSkills.manifest,
             workspace,
             inlineToolHandlers: normalizedSkills.handlers,
+            denoModules: normalizedSkills.denoModules,
             autoEndOnDisconnect,
         };
     }
@@ -593,6 +755,14 @@ 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();
+}
 export class PedelecSession {
     client;
     sessionId;
@@ -1504,6 +1674,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) {

package/dist/index.type-test.js

@@ -1,4 +1,34 @@
-import { Pedelec, defineTool, } from "./index";
+import { Pedelec, defineTool, defineDenoModule, } from "./index";
+const spriteTools = defineDenoModule({
+    name: "sprite-tools",
+    description: "Sprite authoring utilities.",
+    entry: "./agent/sprite-tools.ts",
+    usage: `import { previewActorSource } from "sprite-tools";`,
+    preferStdinExecution: true,
+});
+const spriteName = spriteTools.name;
+const spriteDefinition = spriteTools;
+void spriteName;
+void spriteDefinition;
+// @ts-expect-error Deno Module usage is required by the public authoring API
+defineDenoModule({
+    name: "missing-usage",
+    description: "Missing usage.",
+    entry: "./agent/missing-usage.ts",
+});
+// @ts-expect-error Deno Module entry remains required at authoring time
+defineDenoModule({
+    name: "missing-entry",
+    description: "Missing entry.",
+    usage: 'import "missing-entry";',
+});
+defineDenoModule({
+    name: "non-string-entry",
+    description: "Invalid entry.",
+    // @ts-expect-error Deno Module entry is a build-time string authoring field
+    entry: 42,
+    usage: 'import "non-string-entry";',
+});
 function workspaceInputHasPublicType() {
     return { path: "C:\\workspace\\project" };
 }
@@ -20,6 +50,7 @@ async function typedOnToolNameFromCreateSession() {
                     argsSchema: { type: "object", properties: {}, required: [] },
                 }),
             ],
+            denoModules: [spriteTools],
         },
     });
     session.onTool((name, args, ctx) => {
@@ -115,8 +146,8 @@ async function effortLevelPublicTypeContract() {
     pedelec.createSession({ provider: "codex", sandbox: { path: "C:\\workspace\\legacy" } });
     // @ts-expect-error the removed sandbox picker is not part of the public contract
     pedelec.sandboxFolderPicker();
-    // @ts-expect-error model is no longer a createSession option
-    pedelec.createSession({ provider: "codex", model: "gpt-5" });
+    await pedelec.createSession({ model: "gpt-5" });
+    await pedelec.createSession({ provider: "codex", model: "gpt-5", effortLevel: "high" });
     // @ts-expect-error session no longer exposes provider model
     session.model;
     // @ts-expect-error unsupported effort level

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.3.3";
+export declare const SDK_VERSION = "0.3.4";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // Generated from sdk/package.json. Do not edit manually.
-export const SDK_VERSION = "0.3.3";
+export const SDK_VERSION = "0.3.4";

package/dist/vite.d.ts

@@ -0,0 +1,9 @@
+import { type Plugin } from "vite";
+/**
+ * Vite build-time support for the static Deno module authoring API.
+ *
+ * The plugin deliberately keeps the generated module inside the transformed
+ * browser module. The SDK can consume the non-enumerable private artifact in
+ * a later transport phase without giving the runtime the original entry path.
+ */
+export declare function pedelecVitePlugin(): Plugin;