@poe-platform/safe-bash 0.1.803 → 0.1.804

package/dist/safe-bash/chunks/{chunk-EEEWOYEG.js → chunk-S4RFUUXO.js}

@@ -1,7 +1,9 @@
 import {
-  createOutputOperation,
+  createOutputOperation
+} from "./chunk-RUR6J33T.js";
+import {
   sha256
-} from "./chunk-HZAMGT5I.js";
+} from "./chunk-67WIFM3N.js";
 import {
   PythonFailure,
   PythonInvocationError,
@@ -14,32 +16,32 @@ import {
   pythonStatProjection,
   pythonTreeCleanup,
   reportPythonFailure
-} from "./chunk-LVOBFF4D.js";
+} from "./chunk-Q4FNLOTI.js";
 import {
   openCommandFile
-} from "./chunk-I5HZ4FGE.js";
-import {
-  FsError
-} from "./chunk-VTH3MLDU.js";
+} from "./chunk-CL2FCTTO.js";
 import {
   dirname,
   inheritYieldCheckpoint,
   resolvePath,
   yieldTurn
-} from "./chunk-5OHX7C2V.js";
+} from "./chunk-62BOHHJT.js";
+import {
+  FsError
+} from "./chunk-DUTAG6ZD.js";
 import {
   readBytes,
   writeBytes
-} from "./chunk-74GHTNJA.js";
+} from "./chunk-4KTMKD5W.js";
 import {
   validateExitCode
-} from "./chunk-7R5BDCG7.js";
+} from "./chunk-OHML2BEU.js";
 import {
   pathOf
-} from "./chunk-E7OYNDGL.js";
+} from "./chunk-V7QT2RWC.js";
 import {
   init_platform
-} from "./chunk-B7TAL7S5.js";
+} from "./chunk-PTAEWLSE.js";
 
 // packages/safe-bash/src/commands/python/index.ts
 init_platform();
@@ -1043,7 +1045,7 @@ function createPythonShellCapability(context, options = {}) {
 
 // packages/safe-bash/src/commands/python/llm-capability.ts
 init_platform();
-import { loadLlmStoredSchema, selectLlmModelByQuery, getLlmModelAliases, createLlmConfiguration, createLlmTemplateStore, evaluateLlmTemplate, findExtractedRange, llmTemplateUsesInput, validateLlmTemplateParameters } from "../../safe-bash-command-llm/index.js";
+import { parseLlmSchemaDsl, loadLlmStoredSchema, selectLlmModelByQuery, getLlmModelAliases, createLlmConfiguration, createLlmTemplateStore, evaluateLlmTemplate, findExtractedRange, llmTemplateUsesInput, validateLlmTemplateParameters } from "../../safe-bash-command-llm/index.js";
 
 // packages/safe-bash/src/commands/llm/mime.ts
 init_platform();
@@ -1243,6 +1245,33 @@ ${input}` : evaluated.prompt : input,
       }
       for (const value2 of inputs) {
         const attachment = record(value2);
+        if (attachment.content !== void 0) {
+          const content = attachment.content;
+          if (!Array.isArray(content) || !content.every((byte) => typeof byte === "number" && Number.isInteger(byte) && byte >= 0 && byte <= 255)) throw new TypeError("Invalid inline attachment bytes");
+          if (attachment.path !== void 0 || attachment.url !== void 0) throw new TypeError("Invalid inline attachment location");
+          if (attachment.mimeType !== void 0 && typeof attachment.mimeType !== "string") throw new TypeError("Invalid attachment MIME type");
+          if (content.length > inputLimit - admitted) throw new RangeError("LLM input byte limit exceeded");
+          admitted += content.length;
+          context.inputBudget?.check(admitted);
+          const bytes = Uint8Array.from(content);
+          const controller2 = new AbortController();
+          const source2 = { bytes: (async function* () {
+            for (let offset = 0; offset < bytes.length; offset += 16384) {
+              signal.throwIfAborted();
+              controller2.signal.throwIfAborted();
+              const chunk = bytes.subarray(offset, offset + 16384);
+              if (chunk.byteLength > inputLimit - consumed) throw new RangeError("LLM input byte limit exceeded");
+              consumed += chunk.byteLength;
+              context.inputBudget?.check(consumed);
+              yield chunk;
+            }
+          })(), async dispose() {
+            controller2.abort();
+          } };
+          sources.push(source2);
+          attachments.push({ mimeType: attachment.mimeType ?? sniffMimeType("", bytes.subarray(0, 4096)), source: source2 });
+          continue;
+        }
         if (typeof attachment.path !== "string" || !attachment.path || attachment.path.includes("\0") || attachment.path.includes("://")) throw new TypeError("Attachment requires a canonical filesystem path");
         if (attachment.mimeType !== void 0 && typeof attachment.mimeType !== "string") throw new TypeError("Invalid attachment MIME type");
         const path = pathOf(requestContext, attachment.path);
@@ -1355,6 +1384,21 @@ ${input}` : evaluated.prompt : input,
       const operation = record(value);
       const payload = record(operation.payload ?? {});
       jsonBytes(payload, bufferedInputLimit, "input");
+      if (operation.operation === "schema_dsl") {
+        if (typeof payload.schema !== "string" || typeof payload.multi !== "boolean") throw new TypeError("Invalid schema DSL input");
+        const result = parseLlmSchemaDsl(payload.schema, payload.multi);
+        jsonBytes(result, bufferedLimit);
+        return result;
+      }
+      if (operation.operation === "attachment_type") {
+        const prefix = payload.prefix;
+        if (typeof payload.path !== "string" || !Array.isArray(prefix) || prefix.length > 4096 || prefix.some((byte) => typeof byte !== "number" || !Number.isInteger(byte) || byte < 0 || byte > 255)) {
+          throw new TypeError("Invalid bounded attachment prefix");
+        }
+        const result = sniffMimeType(payload.path, Uint8Array.from(prefix));
+        jsonBytes(result, bufferedLimit);
+        return result;
+      }
       if (operation.operation === "load_schema") {
         const id = payload.schema_id;
         if (typeof id !== "string" || !id || id.includes("\0")) throw new TypeError("Stored schema ID must be a nonempty string");
@@ -1372,6 +1416,15 @@ ${input}` : evaluated.prompt : input,
         jsonBytes(result, bufferedLimit);
         return result;
       }
+      if (operation.operation === "resolve_model") {
+        const configuration = createLlmConfiguration(configurationContext(context, payload, signal));
+        const selected = payload.model ?? await configuration.defaultModel();
+        if (selected !== void 0 && typeof selected !== "string") throw new TypeError("Model must be a string");
+        const identity = selected === void 0 ? void 0 : await configuration.resolveAlias(selected);
+        const resolved = service.resolve(identity).model.id;
+        jsonBytes(resolved, bufferedLimit);
+        return resolved;
+      }
       if (operation.operation === "select_model") {
         const queries = payload.queries;
         if (!Array.isArray(queries) || !queries.length || queries.some((query) => typeof query !== "string")) throw new TypeError("Model queries must be a nonempty array of strings");
@@ -1387,7 +1440,13 @@ ${input}` : evaluated.prompt : input,
           id: entry.model.id,
           aliases: getLlmModelAliases(entry, aliases),
           capabilities: [...entry.model.capabilities ?? []],
-          metadata: { provider: entry.provider.name, attachmentTypes: [...entry.model.attachmentTypes ?? []], outputType: entry.model.outputType ?? "text/plain" }
+          metadata: { ...entry.model.options === void 0 ? {} : { options: Object.fromEntries(Object.entries(entry.model.options).map(([name, option]) => [name, {
+            type: option.type,
+            ...option.minimum === void 0 ? {} : { minimum: option.minimum },
+            ...option.maximum === void 0 ? {} : { maximum: option.maximum },
+            ...option.nullable === void 0 ? {} : { nullable: option.nullable },
+            ...option.description === void 0 ? {} : { description: option.description }
+          }])) }, provider: entry.provider.name, attachmentTypes: [...entry.model.attachmentTypes ?? []], outputType: entry.model.outputType ?? "text/plain" }
         }));
         jsonBytes(models, bufferedLimit);
         return models;
@@ -1591,6 +1650,699 @@ import { createPythonNativeSyscalls } from "@poe-platform/safe-fs/core";
 
 // packages/safe-bash/src/commands/python/llm-module.ts
 init_platform();
+
+// packages/safe-bash/src/commands/python/llm-reference-module.ts
+init_platform();
+var pythonLlmReferenceModule = /* @__PURE__ */ (() => String.raw`
+"""Lazy synchronous and asynchronous model responses backed by JavaScript."""
+import asyncio
+import inspect
+import datetime as _datetime
+from dataclasses import dataclass, field
+import os
+import time
+from pydantic import BaseModel, ConfigDict, Field, create_model
+import poe_llm as _core
+
+Error = _core.LlmError
+
+
+class Options(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+
+
+def _sync(awaitable):
+    try:
+        from pyodide.ffi import run_sync
+    except ImportError:
+        # The native path is for capability tests; production suspension is JSPI.
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            global _native_loop
+            if _native_loop is None or _native_loop.is_closed():
+                _native_loop = asyncio.new_event_loop()
+            return _native_loop.run_until_complete(awaitable)
+        awaitable.close()
+        raise RuntimeError("Use the asynchronous model API inside an asyncio event loop")
+    return run_sync(awaitable)
+
+
+_native_loop = None
+
+
+@dataclass
+class Usage:
+    input: object = None
+    output: object = None
+    details: object = None
+
+
+@dataclass
+class Attachment:
+    type: object = None
+    path: object = None
+    url: object = None
+    content: object = None
+    _id: object = None
+
+    def payload(self):
+        if self.content is not None:
+            if not isinstance(self.content, bytes):
+                raise TypeError("Attachment content must be bytes")
+            return {"content": list(self.content), "mimeType": self.resolve_type()}
+        if self.url is not None:
+            raise NotImplementedError("URL attachment acquisition requires shared service support")
+        return _core.Attachment(os.fspath(self.path), self.type).payload()
+
+    def id(self):
+        import hashlib
+        import json
+        if self._id is None:
+            digest = hashlib.sha256()
+            if self.content:
+                digest.update(self.content)
+            elif self.path:
+                with open(self.path, "rb") as source:
+                    for chunk in iter(lambda: source.read(65536), b""):
+                        digest.update(chunk)
+            else:
+                digest.update(json.dumps({"url": self.url}).encode("utf-8"))
+            self._id = digest.hexdigest()
+        return self._id
+
+    def content_bytes(self):
+        if self.content:
+            return self.content
+        if self.path:
+            with open(self.path, "rb") as source:
+                return source.read()
+        if self.url:
+            raise NotImplementedError("URL attachment acquisition requires shared service support")
+        return self.content
+
+    def base64_content(self):
+        import base64
+        return base64.b64encode(self.content_bytes()).decode("utf-8")
+
+    def resolve_type(self):
+        if self.type:
+            return self.type
+        if self.path:
+            with open(self.path, "rb") as source:
+                prefix = source.read(4096)
+        elif self.content:
+            prefix = self.content[:4096]
+        elif self.url:
+            raise NotImplementedError("URL attachment acquisition requires shared service support")
+        else:
+            raise ValueError("Attachment has no type and no content to derive it from")
+        async def resolve():
+            async with _core.Client() as client:
+                payload = {"path": os.fspath(self.path) if self.path else "", "prefix": list(prefix)}
+                return await client._run(lambda: client._bridge.call("attachment_type", payload), client._timeout)
+        return _sync(resolve())
+
+    @classmethod
+    def from_row(cls, row):
+        return cls(_id=row["id"], type=row["type"], path=row["path"], url=row["url"], content=row["content"])
+
+
+class Prompt:
+    def __init__(self, prompt, model, *, fragments=None, attachments=None,
+                 system=None, system_fragments=None, prompt_json=None,
+                 options=None, schema=None, tools=None, tool_results=None):
+        if tools or tool_results:
+            raise NotImplementedError("Tools require shared service support")
+        self._prompt = prompt
+        self.model = model
+        self.fragments = fragments or []
+        self._system = system
+        self.system_fragments = system_fragments or []
+        self.prompt_json = prompt_json
+        self.attachments = list(attachments or [])
+        if schema is not None and hasattr(schema, "model_json_schema"):
+            schema = schema.model_json_schema()
+        self.schema = schema
+        self.options = options or {}
+        self.tools = []
+        self.tool_results = []
+
+    @property
+    def prompt(self):
+        return "\n".join(self.fragments + ([self._prompt] if self._prompt else []))
+
+    @property
+    def system(self):
+        bits = [bit.strip() for bit in self.system_fragments + [self._system or ""] if bit.strip()]
+        return "\n\n".join(bits)
+
+
+_last_id = 0
+
+
+def _new_id():
+    global _last_id
+    _last_id = max((int(time.time() * 1000) << 80) | int.from_bytes(os.urandom(10), "big"), _last_id + 1)
+    alphabet = "0123456789abcdefghjkmnpqrstvwxyz"
+    return "".join(alphabet[(_last_id >> shift) & 31] for shift in range(125, -1, -5))
+
+
+class _Response:
+    def __init__(self, prompt, model, stream, conversation=None, key=None):
+        if prompt.schema and not model.supports_schema:
+            raise ValueError(str(model) + " does not support schemas")
+        self.id = _new_id()
+        self.prompt = prompt
+        self.model = model
+        self.stream = stream
+        self.conversation = conversation
+        self._key = key
+        self._chunks = []
+        self._done = False
+        self._closed = False
+        self._client = None
+        self._iterator = None
+        self._custom_iterator = None
+        self.response_json = None
+        self.input_tokens = None
+        self.output_tokens = None
+        self.token_details = None
+        self.done_callbacks = []
+        self.resolved_model = None
+        self.attachments = []
+        self._tool_calls = []
+        self._prompt_json = None
+        self._start = None
+        self._end = None
+        self._start_utcnow = None
+
+    def set_usage(self, *, input=None, output=None, details=None):
+        self.input_tokens = input
+        self.output_tokens = output
+        self.token_details = details
+
+    def set_resolved_model(self, model_id):
+        self.resolved_model = model_id
+
+    def token_usage(self):
+        import json
+        parts = []
+        if self.input_tokens is not None:
+            parts.append(format(self.input_tokens, ",") + " input")
+        if self.output_tokens is not None:
+            parts.append(format(self.output_tokens, ",") + " output")
+        if self.token_details:
+            parts.append(json.dumps(self.token_details))
+        return ", ".join(parts)
+
+    async def _finish(self):
+        self._end = time.monotonic()
+        self._done = True
+        if self.conversation is not None:
+            self.conversation.responses.append(self)
+        await self._close()
+        callbacks, self.done_callbacks = self.done_callbacks, []
+        for callback in callbacks:
+            value = callback(self)
+            if inspect.isawaitable(value):
+                await value
+
+    async def _close(self):
+        if self._custom_iterator is not None:
+            iterator, self._custom_iterator = self._custom_iterator, None
+            close = getattr(iterator, "aclose", None) or getattr(iterator, "close", None)
+            if close is not None:
+                result = close()
+                if inspect.isawaitable(result):
+                    await result
+        if self._client is not None:
+            await self._client.aclose()
+
+    def _metadata(self, response):
+        # json() returns provider response metadata, not parsed generated text.
+        self.response_json = response.metadata.get("response_json")
+        self.input_tokens = response.usage.get("input_tokens")
+        self.output_tokens = response.usage.get("output_tokens")
+        self.token_details = response.usage.get("details")
+
+    async def _next(self):
+        if self._done or self._closed:
+            raise StopAsyncIteration
+        try:
+            execute = getattr(self.model, "execute", None)
+            if execute is not None:
+                if self._custom_iterator is None:
+                    self._start = time.monotonic()
+                    self._start_utcnow = _datetime.datetime.now(_datetime.timezone.utc)
+                    self._custom_iterator = execute(self.prompt, self.stream, self, self.conversation)
+                try:
+                    if isinstance(self.model, AsyncModel):
+                        chunk = await self._custom_iterator.__anext__()
+                    else:
+                        chunk = next(self._custom_iterator)
+                except (StopIteration, StopAsyncIteration):
+                    await self._finish()
+                    raise StopAsyncIteration
+                self._chunks.append(chunk)
+                return chunk
+            if self._client is None:
+                self._start = time.monotonic()
+                self._start_utcnow = _datetime.datetime.now(_datetime.timezone.utc)
+                self._client = _core.Client(model=self.model.model_id, key=self._key)
+                options = self.prompt.options
+                if hasattr(options, "model_dump"):
+                    options = options.model_dump(exclude_none=True)
+                values = dict(system=self.prompt.system, options=options,
+                              attachments=self.prompt.attachments, schema=self.prompt.schema)
+                if self.conversation is not None:
+                    messages = []
+                    for response in self.conversation.responses:
+                        if response.prompt.system:
+                            messages.append(_core.Message("system", response.prompt.system))
+                        messages.extend((_core.Message("user", response.prompt.prompt or ""),
+                                         _core.Message("assistant", "".join(response._chunks))))
+                    values.update(messages=messages)
+                if not self.stream:
+                    response = await self._client.complete(self.prompt.prompt or "", **values)
+                    self._metadata(response)
+                    self._chunks.append(response.text)
+                    await self._finish()
+                    return response.text
+                self._iterator = self._client.stream(self.prompt.prompt or "", **values)
+            while True:
+                try:
+                    event = await self._iterator.__anext__()
+                except StopAsyncIteration:
+                    await self._finish()
+                    raise
+                if event.type == "response":
+                    self._metadata(event.response)
+                elif event.type == "text":
+                    self._chunks.append(event.text)
+                    return event.text
+        except BaseException:
+            await self._close()
+            raise
+
+
+class Response(_Response):
+    def __str__(self):
+        return self.text()
+
+    def text_or_raise(self):
+        return self.text()
+
+    def duration_ms(self):
+        self.text()
+        return int(((self._end or 0) - (self._start or 0)) * 1000)
+
+    def datetime_utc(self):
+        self.text()
+        return self._start_utcnow.isoformat() if self._start_utcnow else ""
+
+    def __iter__(self):
+        if self._done:
+            yield from self._chunks
+            return
+        try:
+            while True:
+                try:
+                    chunk = _sync(self._next())
+                except StopAsyncIteration:
+                    return
+                yield chunk
+        finally:
+            if not self._done:
+                self.close()
+
+    def text(self):
+        if not self._done:
+            for _ in self:
+                pass
+        return "".join(self._chunks)
+
+    def json(self):
+        self.text()
+        return self.response_json
+
+    def usage(self):
+        self.text()
+        return Usage(self.input_tokens, self.output_tokens, self.token_details)
+
+    def on_done(self, callback):
+        if self._done:
+            callback(self)
+        else:
+            self.done_callbacks.append(callback)
+
+    def close(self):
+        self._closed = True
+        _sync(self._close())
+
+
+class AsyncResponse(_Response):
+    def __await__(self):
+        async def complete():
+            await self.text()
+            return self
+        return complete().__await__()
+
+    def text_or_raise(self):
+        if not self._done:
+            raise ValueError("Response not yet awaited")
+        return "".join(self._chunks)
+
+    async def duration_ms(self):
+        await self.text()
+        return int(((self._end or 0) - (self._start or 0)) * 1000)
+
+    async def datetime_utc(self):
+        await self.text()
+        return self._start_utcnow.isoformat() if self._start_utcnow else ""
+
+    async def to_sync_response(self):
+        await self.text()
+        conversation = self.conversation.to_sync_conversation() if self.conversation else None
+        response = Response(self.prompt, self.model, self.stream, conversation=conversation)
+        for name in ("id", "_done", "_end", "_start", "_start_utcnow", "input_tokens",
+                     "output_tokens", "token_details", "_prompt_json", "response_json", "resolved_model"):
+            setattr(response, name, getattr(self, name))
+        response._chunks = list(self._chunks)
+        response._tool_calls = list(self._tool_calls)
+        response.attachments = list(self.attachments)
+        return response
+
+    def __aiter__(self):
+        if self._done:
+            self._replay = iter(self._chunks)
+        return self
+
+    async def __anext__(self):
+        if self._done:
+            try:
+                return next(getattr(self, "_replay", iter(())))
+            except StopIteration:
+                raise StopAsyncIteration from None
+        return await self._next()
+
+    async def text(self):
+        if not self._done:
+            async for _ in self:
+                pass
+        return "".join(self._chunks)
+
+    async def json(self):
+        await self.text()
+        return self.response_json
+
+    async def usage(self):
+        await self.text()
+        return Usage(self.input_tokens, self.output_tokens, self.token_details)
+
+    async def on_done(self, callback):
+        if self._done:
+            value = callback(self)
+            if inspect.isawaitable(value):
+                await value
+        else:
+            self.done_callbacks.append(callback)
+
+    async def aclose(self):
+        self._closed = True
+        await self._close()
+
+
+class Model:
+    class Options(Options):
+        pass
+    supports_schema = False
+    supports_tools = False
+    attachment_types = set()
+
+    def __init__(self, model_id=None, *, capabilities=None, metadata=None):
+        if model_id is not None:
+            self.model_id = model_id
+        if capabilities is not None:
+            self.supports_schema = "schema" in capabilities
+        if metadata is not None:
+            self.attachment_types = set(metadata.get("attachmentTypes", ()))
+            if "options" not in metadata:
+                self.Options = create_model("Options", __base__=type(self).Options, __config__=ConfigDict(extra="allow"))
+            else:
+                from typing import Optional
+                types = {"number": float, "integer": int, "boolean": bool, "string": str}
+                fields = {}
+                for name, declaration in metadata["options"].items():
+                    value_type = types[declaration["type"]]
+                    if declaration.get("nullable"):
+                        value_type = Optional[value_type]
+                    constraints = {}
+                    for source, target in (("minimum", "ge"), ("maximum", "le"), ("description", "description")):
+                        if source in declaration:
+                            constraints[target] = declaration[source]
+                    fields[name] = (value_type, Field(default=None, **constraints))
+                self.Options = create_model("Options", __base__=type(self).Options, **fields)
+
+    def __str__(self):
+        suffix = " (async)" if isinstance(self, AsyncModel) else ""
+        return self.__class__.__name__ + suffix + ": " + self.model_id
+
+    def __repr__(self):
+        return "<" + str(self) + ">"
+
+    def _validate_attachments(self, attachments=None):
+        if attachments and not self.attachment_types:
+            raise ValueError("This model does not support attachments")
+        for attachment in attachments or []:
+            attachment_type = attachment.resolve_type()
+            if attachment_type not in self.attachment_types:
+                raise ValueError(
+                    "This model does not support attachments of type '" + attachment_type
+                    + "', only " + ", ".join(self.attachment_types)
+                )
+
+    def prompt(self, prompt=None, *, fragments=None, attachments=None, system=None,
+               system_fragments=None, stream=True, schema=None, tools=None,
+               tool_results=None, **options):
+        self._validate_attachments(attachments)
+        key = options.pop("key", None)
+        options = self.Options(**options)
+        if schema is not None and hasattr(schema, "model_json_schema"):
+            schema = schema.model_json_schema()
+        return Response(Prompt(prompt, self, system=system, attachments=attachments,
+                               fragments=fragments, system_fragments=system_fragments,
+                               tools=tools, tool_results=tool_results,
+                               schema=schema, options=options), self, stream, key=key)
+
+
+    def conversation(self, tools=None, before_call=None, after_call=None, chain_limit=None):
+        return Conversation(self, tools=tools, before_call=before_call, after_call=after_call, chain_limit=chain_limit)
+
+
+class AsyncModel(Model):
+    def prompt(self, prompt=None, *, fragments=None, attachments=None, system=None,
+               schema=None, tools=None, tool_results=None, system_fragments=None,
+               stream=True, **options):
+        response = super().prompt(prompt, fragments=fragments, attachments=attachments,
+                                  system=system, schema=schema, tools=tools,
+                                  tool_results=tool_results, system_fragments=system_fragments,
+                                  stream=stream, **options)
+        return AsyncResponse(response.prompt, self, stream, key=response._key)
+
+
+    def conversation(self, tools=None, before_call=None, after_call=None, chain_limit=None):
+        return AsyncConversation(self, tools=tools, before_call=before_call, after_call=after_call, chain_limit=chain_limit)
+
+
+@dataclass
+class Conversation:
+    model: object
+    id: str = field(default_factory=_new_id)
+    name: object = None
+    responses: list = field(default_factory=list)
+    tools: object = None
+    chain_limit: object = None
+    before_call: object = None
+    after_call: object = None
+
+    def prompt(self, prompt=None, *, fragments=None, attachments=None, system=None,
+               schema=None, tools=None, tool_results=None, system_fragments=None,
+               stream=True, key=None, **options):
+        response = self.model.prompt(prompt, fragments=fragments, attachments=attachments,
+                                     system=system, schema=schema, tools=tools or self.tools,
+                                     tool_results=tool_results, system_fragments=system_fragments,
+                                     stream=stream, key=key, **options)
+        response.conversation = self
+        return response
+
+
+class AsyncConversation(Conversation):
+    def to_sync_conversation(self):
+        return Conversation(model=self.model, id=self.id, name=self.name, responses=[],
+                            tools=self.tools, chain_limit=self.chain_limit)
+
+
+class UnknownModelError(KeyError):
+    pass
+
+
+async def _models():
+    async with _core.Client() as client:
+        return await client.models()
+
+
+def get_models():
+    return [Model(item.id, capabilities=item.capabilities, metadata=item.metadata) for item in _sync(_models())]
+
+
+def get_async_models():
+    return [AsyncModel(item.id, capabilities=item.capabilities, metadata=item.metadata) for item in _sync(_models())]
+
+
+def get_model_aliases():
+    result = {}
+    for item in _sync(_models()):
+        model = Model(item.id, capabilities=item.capabilities, metadata=item.metadata)
+        for name in (item.id, *item.aliases):
+            result[name] = model
+    return result
+
+
+def get_async_model_aliases():
+    result = {}
+    for item in _sync(_models()):
+        model = AsyncModel(item.id, capabilities=item.capabilities, metadata=item.metadata)
+        for name in (item.id, *item.aliases):
+            result[name] = model
+    return result
+
+
+def get_default_model():
+    async def read():
+        async with _core.Client() as client:
+            return await client._run(lambda: client._bridge.call("resolve_model", _core._configuration_context()), client._timeout)
+    return _sync(read())
+
+
+def get_model(name=None, _skip_async=False):
+    aliases = get_model_aliases()
+    name = name or get_default_model()
+    try:
+        return aliases[name]
+    except KeyError:
+        raise UnknownModelError("Unknown model: " + str(name)) from None
+
+
+def get_async_model(name=None):
+    aliases = get_async_model_aliases()
+    name = name or get_default_model()
+    try:
+        return aliases[name]
+    except KeyError:
+        raise UnknownModelError("Unknown model: " + str(name)) from None
+
+
+def schema_dsl(schema_dsl, multi=False):
+    async def parse():
+        async with _core.Client() as client:
+            payload = {"schema": schema_dsl, "multi": bool(multi)}
+            return await client._run(lambda: client._bridge.call("schema_dsl", payload), client._timeout)
+    return _sync(parse())
+
+
+def encode(values):
+    import struct
+    return struct.pack("<" + "f" * len(values), *values)
+
+
+def decode(binary):
+    import struct
+    return struct.unpack("<" + "f" * (len(binary) // 4), binary)
+
+
+def cosine_similarity(a, b):
+    dot_product = sum(x * y for x, y in zip(a, b))
+    magnitude_a = sum(x * x for x in a) ** 0.5
+    magnitude_b = sum(x * x for x in b) ** 0.5
+    return dot_product / (magnitude_a * magnitude_b)
+
+
+class EmbeddingModel:
+    supports_text = True
+    supports_binary = False
+    batch_size = None
+    key = None
+
+    def __init__(self, model_id=None):
+        if model_id is not None:
+            self.model_id = model_id
+
+    def __str__(self):
+        return self.__class__.__name__ + ": " + self.model_id
+
+    def __repr__(self):
+        return "<" + str(self) + ">"
+
+    def _check(self, item):
+        if not self.supports_binary and isinstance(item, bytes):
+            raise ValueError("This model does not support binary data, only text strings")
+        if not self.supports_text and isinstance(item, str):
+            raise ValueError("This model does not support text strings, only binary data")
+
+    def embed_batch(self, items):
+        async def embed():
+            async with _core.Client(model=self.model_id, key=self.key) as client:
+                return await client.embed(items)
+        result = _sync(embed())
+        for vector in result.vectors:
+            yield list(vector)
+
+    def embed(self, item):
+        self._check(item)
+        return next(iter(self.embed_batch([item])))
+
+    def embed_multi(self, items, batch_size=None):
+        from itertools import islice
+        def checked():
+            for item in items:
+                self._check(item)
+                yield item
+        iterator = checked()
+        effective_batch_size = self.batch_size if batch_size is None else batch_size
+        if effective_batch_size is None:
+            yield from self.embed_batch(iterator)
+            return
+        while True:
+            batch = list(islice(iterator, effective_batch_size))
+            if not batch:
+                return
+            yield from self.embed_batch(batch)
+
+
+def get_embedding_models():
+    return [EmbeddingModel(item.id) for item in _sync(_models()) if "embed" in item.capabilities]
+
+
+def get_embedding_model_aliases():
+    result = {}
+    for item in _sync(_models()):
+        if "embed" not in item.capabilities:
+            continue
+        model = EmbeddingModel(item.id)
+        for name in (item.id, *item.aliases):
+            result[name] = model
+    return result
+
+
+def get_embedding_model(name):
+    try:
+        return get_embedding_model_aliases()[name]
+    except KeyError:
+        raise UnknownModelError("Unknown model: " + str(name)) from None
+`)();
+
+// packages/safe-bash/src/commands/python/llm-module.ts
 var pythonLlmModule = /* @__PURE__ */ (() => String.raw`
 """Async Python workflows for the invocation-owned JavaScript LLM service."""
 from __future__ import annotations
@@ -2080,13 +2832,14 @@ class _SafeLlmLoader:
   self._source = source
   self._spec = spec
  def find_spec(self, fullname, path=None, target=None):
-  if fullname == 'poe_llm':
+  if fullname in ('poe_llm', 'llm'):
    return self._spec(fullname, self, origin='poe_llm.py')
  def create_module(self, spec):
   return None
  def exec_module(self, module):
-  module.__file__ = 'poe_llm.py'
-  exec(compile(self._source, 'poe_llm.py', 'exec'), module.__dict__)
+  module.__file__ = module.__name__ + '.py'
+  source = self._source if module.__name__ == 'poe_llm' else ${JSON.stringify(pythonLlmReferenceModule)}
+  exec(compile(source, module.__file__, 'exec'), module.__dict__)
 _safe_llm_sys.meta_path.insert(0, _SafeLlmLoader(_safe_llm_source, _safe_llm_imports.ModuleSpec))
 del _SafeLlmLoader, _safe_llm_sys, _safe_llm_imports
 `);
@@ -3359,6 +4112,65 @@ function createPythonJspiAssets(options) {
   } };
 }
 
+// packages/safe-bash/src/commands/python/llm-dependencies.ts
+init_platform();
+var pythonLlmDependencies = Object.freeze({
+  pyodideVersion: "314.0.6",
+  baseUrl: "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/",
+  archives: Object.freeze([
+    {
+      "fileName": "typing_extensions-4.15.0-py3-none-any.whl",
+      "byteLength": 44613,
+      "sha256": "3f122252f0d498d80f7a684cc1d8baa6fa65b75e99447d77a6dd90e0f04302e3"
+    },
+    {
+      "fileName": "typing_inspection-0.4.2-py3-none-any.whl",
+      "byteLength": 14610,
+      "sha256": "c9270737700f07813e1a87b63138993997afedbd2548f20fa739cc398f1b9f2f"
+    },
+    {
+      "fileName": "annotated_types-0.7.0-py3-none-any.whl",
+      "byteLength": 11963,
+      "sha256": "6b34f564725f8d309442f8d15abcceed1bf140fe2412e2c58da721426ae2222e"
+    },
+    {
+      "fileName": "pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+      "byteLength": 1310163,
+      "sha256": "9802bd7a5e6679ec4c13be778f19f021e6147459c89cc916b913f7970f86dddb"
+    },
+    {
+      "fileName": "pydantic-2.12.5-py3-none-any.whl",
+      "byteLength": 463578,
+      "sha256": "52d15d19fbe2a62ac9b63348df7b38e5ebb186063a9b923a837dd6e43273b414"
+    }
+  ].map((archive) => Object.freeze(archive))),
+  nativeModules: Object.freeze([Object.freeze({
+    archive: "pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
+    path: "pydantic_core/_pydantic_core.cpython-314-wasm32-emscripten.so",
+    sha256: "94477475eb48c67b6b25fd47a7955c1d01479f7971522aff90215bb517be8246"
+  })])
+});
+async function installPythonLlmDependencies(runtime, archives) {
+  if (runtime.version !== pythonLlmDependencies.pyodideVersion) throw new Error("Python LLM dependencies require Pyodide 314.0.6");
+  const supplied = new Map(archives.map((archive) => [archive.fileName, archive.bytes]));
+  if (archives.length !== pythonLlmDependencies.archives.length || supplied.size !== archives.length || pythonLlmDependencies.archives.some((archive) => !supplied.has(archive.fileName))) {
+    throw new Error("A complete pinned Python LLM dependency bundle is required");
+  }
+  const snapshots = pythonLlmDependencies.archives.map((archive) => {
+    const bytes = supplied.get(archive.fileName);
+    if (!(bytes instanceof Uint8Array) || bytes.byteLength !== archive.byteLength) {
+      throw new Error("Python LLM dependency size or digest mismatch: " + archive.fileName);
+    }
+    return { archive, bytes: new Uint8Array(bytes) };
+  });
+  for (const { archive, bytes } of snapshots) {
+    const digest2 = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+    const sha2562 = Array.from(digest2, (value) => value.toString(16).padStart(2, "0")).join("");
+    if (sha2562 !== archive.sha256) throw new Error("Python LLM dependency digest mismatch: " + archive.fileName);
+  }
+  for (const { bytes } of snapshots) runtime.unpackArchive(bytes, "zip", { extractDir: "/lib/python3.14/site-packages" });
+}
+
 // packages/safe-bash/src/commands/python/index.ts
 var PythonInputChunkError = class extends RangeError {
 };
@@ -3367,14 +4179,15 @@ function createPythonCommands(options) {
   if (options.createCapabilities && !options.createExecutor) throw new TypeError("Python host capabilities require an asynchronous executor");
   if (options.onDiagnostic !== void 0 && typeof options.onDiagnostic !== "function") throw new TypeError("Python onDiagnostic must be a function");
   if (options.environment && options.provisioning) throw new TypeError("A borrowed Python environment cannot be combined with provisioning options");
-  const maxTransferBytes = options.maxTransferBytes ?? 65536;
+  const maxTransferBytes = options.maxTransferBytes ?? Infinity;
+  const transferChunkBytes = Math.min(maxTransferBytes, 65536);
   const maxOpenFiles = options.maxOpenFiles;
   const maxConcurrentWorkers = options.maxConcurrentWorkers ?? Infinity;
   const maxInputChunkBytes = options.maxInputChunkBytes ?? Infinity;
-  if (options.maxConcurrentWorkers !== void 0 && (!Number.isSafeInteger(maxConcurrentWorkers) || maxConcurrentWorkers < 1)) throw new RangeError("Invalid Python worker concurrency limit");
-  if (options.maxInputChunkBytes !== void 0 && (!Number.isSafeInteger(maxInputChunkBytes) || maxInputChunkBytes < 1)) throw new RangeError("Invalid Python input chunk limit");
+  if (maxConcurrentWorkers !== Infinity && (!Number.isSafeInteger(maxConcurrentWorkers) || maxConcurrentWorkers < 1)) throw new RangeError("Invalid Python worker concurrency limit");
+  if (maxInputChunkBytes !== Infinity && (!Number.isSafeInteger(maxInputChunkBytes) || maxInputChunkBytes < 1)) throw new RangeError("Invalid Python input chunk limit");
   let activeWorkers = 0;
-  for (const size of [maxTransferBytes, maxOpenFiles, options.maxDirectoryEntries]) if (size !== void 0 && (!Number.isSafeInteger(size) || size < 1)) throw new RangeError("Invalid Python resource limit");
+  for (const size of [maxTransferBytes, maxOpenFiles, options.maxDirectoryEntries]) if (size !== void 0 && size !== Infinity && (!Number.isSafeInteger(size) || size < 1)) throw new RangeError("Invalid Python resource limit");
   const runtimeMount = options.runtimeMount ?? "/.pyodide-runtime";
   if (!runtimeMount.startsWith("/") || runtimeMount === "/" || runtimeMount.slice(1).includes("/") || runtimeMount.includes("\0") || runtimeMount.split("/").some((part) => part === ".." || part === ".")) throw new TypeError("Python runtime mount must be an absolute top-level canonical path");
   const environment = options.environment ?? createPythonPackageEnvironment(options.provisioning);
@@ -3526,7 +4339,7 @@ function createPythonCommands(options) {
       if (options.createCapabilities) {
         const capabilityInput = { async *[Symbol.asyncIterator]() {
           while (true) {
-            const bytes = await dispatch({ op: "stdin", args: [maxTransferBytes] });
+            const bytes = await dispatch({ op: "stdin", args: [transferChunkBytes] });
             if (!bytes.length) break;
             yield Uint8Array.from(bytes);
           }
@@ -3634,7 +4447,7 @@ function createPythonCommands(options) {
       } else {
         let shared;
         try {
-          shared = new SharedArrayBuffer(8 + maxTransferBytes * 6 + 65536);
+          shared = new SharedArrayBuffer(8 + transferChunkBytes * 6 + 65536);
         } catch (reason) {
           throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
         }
@@ -3752,7 +4565,7 @@ function createPythonCommands(options) {
             transportFailure(reason);
           }
           if (settled) return;
-          const start = { type: "start", shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes, ...packages ? { packages } : {}, installOnly: !!installation };
+          const start = { type: "start", shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes: transferChunkBytes, ...packages ? { packages } : {}, installOnly: !!installation };
           signal.throwIfAborted();
           try {
             endpoint.postMessage(start);
@@ -3823,6 +4636,8 @@ export {
   createPythonJspiStatResult,
   createPythonJspiExecutor,
   createPythonJspiAssets,
+  pythonLlmDependencies,
+  installPythonLlmDependencies,
   createPythonCommands,
   pythonCommands
 };