mirror of
https://gitee.com/zhangsken/opencode.git
synced 2026-11-18 09:42:01 +08:00
Compare commits
12 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
| 5910c5049e | |||
| fe09a2e9b7 | |||
| 59202356fe | |||
| 637282f3b9 | |||
| d1550cb599 | |||
| ed6c117184 | |||
| 6ce62bd84a | |||
| a4a948316b | |||
| aca3b7813d | |||
| 0eaa75ec0f | |||
| 6b3c4f5839 | |||
| 8e76adb08f |
@@ -1 +1,4 @@
|
||||
preload = ["@opentui/solid/preload"]
|
||||
|
||||
[test]
|
||||
preload = ["@opentui/solid/preload"]
|
||||
|
||||
@@ -778,19 +778,26 @@ export function createPromptState(input: PromptInput): PromptState {
|
||||
if (!area || area.isDestroyed) return false
|
||||
|
||||
const endOffset = Bun.stringWidth(area.plainText)
|
||||
if (dir === -1 && area.visualCursor.visualRow === 0) {
|
||||
area.cursorOffset = 0
|
||||
if (dir === -1) {
|
||||
if (area.cursorOffset === 0) return false
|
||||
if (area.visualCursor.visualRow === 0) {
|
||||
area.cursorOffset = 0
|
||||
return
|
||||
}
|
||||
area.moveCursorUp()
|
||||
return
|
||||
}
|
||||
|
||||
const end =
|
||||
typeof area.height === "number" && Number.isFinite(area.height) && area.height > 0
|
||||
? area.height - 1
|
||||
: Math.max(0, (area.virtualLineCount ?? 1) - 1)
|
||||
if (dir === 1 && area.visualCursor.visualRow === end) {
|
||||
if (area.cursorOffset === endOffset) return false
|
||||
if (area.visualCursor.visualRow === end) {
|
||||
area.cursorOffset = endOffset
|
||||
return
|
||||
}
|
||||
|
||||
return false
|
||||
area.moveCursorDown()
|
||||
}
|
||||
|
||||
const requestExit = () => {
|
||||
@@ -1037,6 +1044,7 @@ export function createPromptState(input: PromptInput): PromptState {
|
||||
}))
|
||||
|
||||
useBindings(() => ({
|
||||
priority: 1,
|
||||
mode: OPENCODE_BASE_MODE,
|
||||
enabled: input.prompt() && !visible(),
|
||||
commands: [
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
/** @jsxImportSource @opentui/solid */
|
||||
import { createDefaultOpenTuiKeymap } from "@opentui/keymap/opentui"
|
||||
import { testRender, useRenderer } from "@opentui/solid"
|
||||
import { OpencodeKeymapProvider, registerOpencodeKeymap } from "@opencode-ai/tui/keymap"
|
||||
import { resolve } from "@opencode-ai/tui/config"
|
||||
import { expect, test } from "bun:test"
|
||||
import { createComponent, createSignal } from "solid-js"
|
||||
import { RunFooterView } from "../src/mini/footer.view"
|
||||
import { RUN_THEME_FALLBACK } from "../src/mini/theme"
|
||||
import type { FooterState, FooterSubagentState, FooterView } from "../src/mini/types"
|
||||
|
||||
test("down opens subagents from an empty prompt", async () => {
|
||||
const [state] = createSignal<FooterState>({
|
||||
phase: "idle",
|
||||
status: "",
|
||||
queue: 0,
|
||||
model: "gpt-5",
|
||||
duration: "",
|
||||
usage: "",
|
||||
first: false,
|
||||
interrupt: 0,
|
||||
exit: 0,
|
||||
})
|
||||
const [view] = createSignal<FooterView>({ type: "prompt" })
|
||||
const [subagents] = createSignal<FooterSubagentState>({
|
||||
tabs: [
|
||||
{
|
||||
sessionID: "subagent-1",
|
||||
partID: "part-1",
|
||||
callID: "call-1",
|
||||
label: "Explore",
|
||||
description: "Inspect the keymap",
|
||||
status: "running",
|
||||
lastUpdatedAt: 1,
|
||||
},
|
||||
],
|
||||
details: {},
|
||||
permissions: [],
|
||||
questions: [],
|
||||
})
|
||||
const config = resolve(
|
||||
{ keybinds: { editor_open: "none", session_queued_prompts: "none" } },
|
||||
{ terminalSuspend: true },
|
||||
)
|
||||
let offKeymap: (() => void) | undefined
|
||||
|
||||
function Harness() {
|
||||
const renderer = useRenderer()
|
||||
const keymap = createDefaultOpenTuiKeymap(renderer)
|
||||
offKeymap = registerOpencodeKeymap(keymap, renderer, config)
|
||||
|
||||
return createComponent(OpencodeKeymapProvider, {
|
||||
keymap,
|
||||
get children() {
|
||||
return (
|
||||
<RunFooterView
|
||||
directory="/tmp"
|
||||
findFiles={async () => []}
|
||||
agents={() => []}
|
||||
references={() => []}
|
||||
commands={() => []}
|
||||
providers={() => undefined}
|
||||
currentModel={() => undefined}
|
||||
variants={() => []}
|
||||
currentVariant={() => undefined}
|
||||
state={state}
|
||||
view={view}
|
||||
subagent={subagents}
|
||||
theme={() => RUN_THEME_FALLBACK}
|
||||
tuiConfig={config}
|
||||
agent="opencode"
|
||||
onSubmit={() => true}
|
||||
onPermissionReply={() => {}}
|
||||
onQuestionReply={() => {}}
|
||||
onQuestionReject={() => {}}
|
||||
onCycle={() => {}}
|
||||
onInterrupt={() => false}
|
||||
onEditorOpen={async () => undefined}
|
||||
onInputClear={() => {}}
|
||||
onExit={() => {}}
|
||||
onModelSelect={() => {}}
|
||||
onVariantSelect={() => {}}
|
||||
onRows={() => {}}
|
||||
onLayout={() => {}}
|
||||
onStatus={() => {}}
|
||||
onQueuedRemove={async () => true}
|
||||
/>
|
||||
)
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
const app = await testRender(() => <Harness />, { width: 100, height: 8, kittyKeyboard: true })
|
||||
try {
|
||||
await app.renderOnce()
|
||||
expect(app.renderer.currentFocusedEditor?.plainText).toBe("")
|
||||
app.mockInput.pressArrow("down")
|
||||
await app.renderOnce()
|
||||
expect(app.captureCharFrame()).toContain("Select subagent")
|
||||
} finally {
|
||||
app.renderer.currentFocusedRenderable?.blur()
|
||||
app.renderer.currentFocusedEditor?.blur()
|
||||
offKeymap?.()
|
||||
app.renderer.destroy()
|
||||
}
|
||||
})
|
||||
@@ -64,10 +64,16 @@ path lookup, namespace browsing, deterministic ranking, and pagination.
|
||||
### Tool execution
|
||||
|
||||
Every sandbox promise starts eagerly on a run-once fiber owned by the whole CodeMode execution, including tool calls,
|
||||
async functions, `Promise.all`, `Promise.allSettled`, `Promise.race`, `Promise.resolve`, and `Promise.reject`. Nested
|
||||
functions therefore cannot end the lifetime of work they started. Independent aggregate batches overlap, and rejection
|
||||
is observed at the eventual `await`. `Promise.race` uses native non-cancelling settlement semantics: its first result
|
||||
wins while losers continue running. At normal completion CodeMode interrupts everything still running - race losers,
|
||||
async functions, chained `.then`/`.catch`/`.finally` reactions, `new Promise(executor)` constructions, and the
|
||||
`Promise.all`/`allSettled`/`race`/`any`/`resolve`/`reject` statics. Nested functions therefore cannot end the lifetime
|
||||
of work they started.
|
||||
Independent aggregate batches overlap, and rejection is observed at the eventual `await` or chained rejection handler.
|
||||
`Promise.race` and `Promise.any` use native non-cancelling settlement semantics: the deciding member wins while losers
|
||||
continue running, and an all-rejected `Promise.any` rejects with an `AggregateError`. `new Promise(...)` hands the
|
||||
executor first-class resolve/reject callables that may escape and settle the promise later, exactly once.
|
||||
Reaction ordering matches what V8 makes observable - handlers and await continuations are deferred and run in attach
|
||||
order, and a combinator settles one reaction turn after its deciding member - without promising exact microtask-count
|
||||
parity beyond that. At normal completion CodeMode interrupts everything still running - race losers,
|
||||
fail-fast `Promise.all` stragglers, and fire-and-forget calls alike: the program has returned, so no future await can
|
||||
exist, and work whose completion matters must be awaited by the program. Waiting for any class of leftover instead
|
||||
would let it hold the execution open, or deadlock it when queued work needs tool-call permits the leftovers occupy.
|
||||
|
||||
@@ -92,8 +92,9 @@ ultimate source of truth.
|
||||
- [x] Optional property access and optional calls.
|
||||
- [x] Function/tool calls and spread arguments.
|
||||
- [x] Sequence expressions (the comma operator).
|
||||
- [x] `await` for sandbox promises; awaiting a plain value is a no-op.
|
||||
- [x] `new` for Error types, Date, RegExp, Map, Set, URL, and URLSearchParams.
|
||||
- [x] `await` for sandbox promises; a plain value passes through unchanged, though every `await` still defers its
|
||||
continuation one reaction turn.
|
||||
- [x] `new` for Error types, Date, RegExp, Map, Set, URL, URLSearchParams, and Promise.
|
||||
- [x] Arithmetic operators: `+`, `-`, `*`, `/`, `%`, and `**`.
|
||||
- [x] Equality and ordering: `==`, `!=`, `===`, `!==`, `<`, `<=`, `>`, and `>=`.
|
||||
- [x] Bitwise operators: `&`, `|`, `^`, `~`, `<<`, `>>`, and `>>>`.
|
||||
@@ -102,27 +103,41 @@ ultimate source of truth.
|
||||
- [x] Prefix and postfix `++` and `--`.
|
||||
- [x] Plain, arithmetic, bitwise, and logical assignment operators.
|
||||
- [ ] Unary `void` and `delete`.
|
||||
- [ ] Arbitrary constructors and `new Promise(...)`.
|
||||
- [ ] Arbitrary constructors.
|
||||
|
||||
## Promises and tools
|
||||
|
||||
- [x] Tool calls start eagerly and return supervised, run-once sandbox promises.
|
||||
- [x] Direct `await`, repeated awaits, and implicit resolution when a promise is returned from a function/program.
|
||||
- [x] `Promise.resolve` and `Promise.reject`.
|
||||
- [x] `Promise.all`, `Promise.allSettled`, and `Promise.race` over supported collections containing promises and plain
|
||||
values.
|
||||
- [x] `Promise.all`, `Promise.allSettled`, `Promise.race`, and `Promise.any` over supported collections containing
|
||||
promises and plain values.
|
||||
- [x] `Promise.all` preserves result order and rejects on the first observed failure without cancelling siblings.
|
||||
- [x] `Promise.allSettled` returns plain fulfilled/rejected outcome records.
|
||||
- [x] `Promise.race` settles from the first result without cancelling losers at settlement time.
|
||||
- [x] Real promise values from `Promise.all`, `Promise.allSettled`, and `Promise.race`; separately constructed
|
||||
combinator batches overlap as in normal JavaScript.
|
||||
- [x] Promise chaining with `.then`, `.catch`, and `.finally`: handlers run deferred in attach order, returned
|
||||
promises are adopted, handler throws reject the derived promise, `.finally` preserves the original settlement
|
||||
unless its cleanup fails, and direct self-resolution rejects with a `TypeError`.
|
||||
- [x] Every `await` (including of plain values and already-settled promises) defers its continuation one reaction
|
||||
turn, so concurrent async functions interleave at await points as in JavaScript.
|
||||
- [x] Combinators settle one reaction turn after their deciding member (V8-observable ordering): reactions already
|
||||
attached to members run first, and an aggregate cannot beat a plain value settling in the same turn into a
|
||||
`Promise.race`. Exact microtask-count parity beyond this observable ordering is not a documented guarantee.
|
||||
- [x] All still-pending work (race losers, fail-fast `Promise.all` stragglers, and un-awaited calls alike) is
|
||||
interrupted when the program returns; rejections that settled un-awaited become `Success.warnings`
|
||||
diagnostics.
|
||||
diagnostics. A combinator abandoned inside its final settlement turn counts as pending and is interrupted
|
||||
without a warning.
|
||||
- [x] `try`/`catch` can handle awaited tool and promise failures.
|
||||
- [ ] `Promise.any`.
|
||||
- [ ] Promise chaining with `.then`, `.catch`, and `.finally`.
|
||||
- [ ] Custom promise construction with `new Promise(...)`.
|
||||
- [x] `Promise.any`: first fulfillment wins; all-rejected rejects with an `AggregateError` whose `errors` array holds
|
||||
the catch-normalized reasons in input order, and empty input rejects with an empty `AggregateError`.
|
||||
- [x] `new Promise((resolve, reject) => ...)`: the executor runs synchronously and receives first-class resolve/reject
|
||||
callables that settle the promise exactly once (they may escape the executor and settle later); an executor
|
||||
throw rejects unless the promise already settled, resolving with a promise adopts it, and resolving with the
|
||||
promise itself rejects with a `TypeError`. Resolver callables work as `.then`/`.catch` handlers and collection
|
||||
callbacks but remain opaque references that cannot cross the data boundary.
|
||||
- [ ] Thenable assimilation (objects with a `then` method are plain data, not promises).
|
||||
- [ ] Async iterables, host streams, and stream consumption.
|
||||
|
||||
## Objects and properties
|
||||
@@ -153,7 +168,7 @@ ultimate source of truth.
|
||||
- [ ] The mapper and `thisArg` forms of `Array.from`.
|
||||
- [ ] `Array.prototype.toSpliced`.
|
||||
- [ ] Canonical index handling: a key such as `"01"` must not alias index `1`.
|
||||
- [ ] Complete sparse-array parity.
|
||||
- [ ] Complete sparse-array parity. Promise combinators do consume holes as `undefined` members, as in JS.
|
||||
- [ ] Correct `findLast` return behavior when its predicate mutates the examined element.
|
||||
|
||||
## Strings
|
||||
@@ -258,6 +273,8 @@ ultimate source of truth.
|
||||
|
||||
- [x] `Error`, `TypeError`, `RangeError`, `SyntaxError`, `ReferenceError`, `EvalError`, and `URIError`, callable with
|
||||
or without `new`.
|
||||
- [x] `AggregateError` with the `(errors, message?)` signature and an own `errors` array, constructed directly or by
|
||||
an all-rejected `Promise.any`.
|
||||
- [x] Error `name`/`message`, error inheritance through `instanceof`, and plain-data serialization.
|
||||
- [x] `instanceof` for Date, RegExp, Map, Set, URL, URLSearchParams, Array, Object, Promise, and Error types.
|
||||
- [x] Catchable interpreter failures and awaited tool failures.
|
||||
|
||||
@@ -1,11 +1,6 @@
|
||||
import { Effect, Schema } from "effect"
|
||||
import { executeWithLimits } from "./interpreter/runtime.js"
|
||||
import {
|
||||
type HostTools,
|
||||
type Services,
|
||||
type ToolDescription,
|
||||
ToolRuntime,
|
||||
} from "./tool-runtime.js"
|
||||
import { type HostTools, type Services, type ToolDescription, ToolRuntime } from "./tool-runtime.js"
|
||||
import type { Definition } from "./tool.js"
|
||||
|
||||
/** A tool call admitted during an execution. */
|
||||
@@ -130,11 +125,7 @@ export type Runtime<R = never> = {
|
||||
readonly execute: (code: string) => Effect.Effect<Result, never, R>
|
||||
}
|
||||
|
||||
const validateLimit = <Value extends number | undefined>(
|
||||
name: keyof ExecutionLimits,
|
||||
value: Value,
|
||||
minimum: number,
|
||||
): Value => {
|
||||
const validateLimit = (name: keyof ExecutionLimits, value: number | undefined, minimum: number): number | undefined => {
|
||||
if (value !== undefined && (!Number.isSafeInteger(value) || value < minimum)) {
|
||||
throw new RangeError(`${name} must be a safe integer greater than or equal to ${minimum}.`)
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import type { SafeObject } from "../tool-runtime.js"
|
||||
import type { SandboxURL } from "../values.js"
|
||||
import type { SandboxPromise, SandboxURL } from "../values.js"
|
||||
|
||||
export type SourcePosition = {
|
||||
line: number
|
||||
@@ -61,12 +61,27 @@ export class ComputedValue {
|
||||
|
||||
export class PromiseNamespace {}
|
||||
|
||||
export type PromiseMethodName = "all" | "allSettled" | "race" | "resolve" | "reject"
|
||||
export type PromiseMethodName = "all" | "allSettled" | "race" | "any" | "resolve" | "reject"
|
||||
|
||||
export class PromiseMethodReference {
|
||||
constructor(readonly name: PromiseMethodName) {}
|
||||
}
|
||||
|
||||
export type PromiseInstanceMethodName = "then" | "catch" | "finally"
|
||||
|
||||
export class PromiseInstanceMethodReference {
|
||||
constructor(
|
||||
readonly promise: SandboxPromise,
|
||||
readonly name: PromiseInstanceMethodName,
|
||||
) {}
|
||||
}
|
||||
|
||||
// The resolve/reject callables handed to a `new Promise(executor)` executor. `settle` closes
|
||||
// over the promise's deferred and is first-settlement-wins; later calls are no-ops, as in JS.
|
||||
export class PromiseCapabilityFunction {
|
||||
constructor(readonly settle: (value: unknown) => void) {}
|
||||
}
|
||||
|
||||
export type GlobalNamespaceName =
|
||||
| "Object"
|
||||
| "Math"
|
||||
@@ -122,11 +137,11 @@ export type DiagnosticKind =
|
||||
export const OptionalShortCircuit: unique symbol = Symbol("codemode.optional-short-circuit")
|
||||
|
||||
export const supportedSyntaxMessage =
|
||||
"Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, and Promise.all/allSettled/race/resolve/reject over arrays mixing promises and plain values for parallel tool calls (promise chaining with .then/.catch is not supported - use await with try/catch)."
|
||||
"Supported orchestration syntax: tools.* calls (they return promises - resolve them with await), data literals, destructuring, optional chaining, template literals, conditionals, switch, loops (incl. for...of and for...in over object/array/tools keys), arrow functions, spread, try/catch, array methods (map/filter/find/findIndex/some/every/reduce/flatMap/forEach/sort/slice/concat/indexOf/lastIndexOf/at/flat/reverse/includes/join), string methods (incl. match/matchAll/replace/split with regular expressions), Date/RegExp/Map/Set/URL/URLSearchParams, URI encoding helpers, Object/Math/JSON helpers, captured console.log/warn/error/dir/table, Promise.all/allSettled/race/any/resolve/reject over arrays mixing promises and plain values for parallel tool calls, promise chaining with .then/.catch/.finally, and new Promise((resolve, reject) => ...) construction."
|
||||
|
||||
export class InterpreterRuntimeError extends Error {
|
||||
readonly node?: AstNode
|
||||
errorName: string = "Error"
|
||||
errorName = "Error"
|
||||
|
||||
constructor(
|
||||
message: string,
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
import { parse } from "acorn"
|
||||
import { Cause, Effect, Exit, Fiber, Scope, Semaphore } from "effect"
|
||||
import { Cause, Deferred, Effect, Exit, Fiber, Scope, Semaphore } from "effect"
|
||||
import { DiagnosticCategory, ModuleKind, ScriptTarget, flattenDiagnosticMessageText, transpileModule } from "typescript"
|
||||
import {
|
||||
copyIn,
|
||||
@@ -31,7 +31,6 @@ import {
|
||||
ErrorConstructorReference,
|
||||
GlobalMethodReference,
|
||||
GlobalNamespace,
|
||||
type GlobalNamespaceName,
|
||||
formatLocation,
|
||||
getArray,
|
||||
getBoolean,
|
||||
@@ -43,6 +42,8 @@ import {
|
||||
isRecord,
|
||||
type MemberReference,
|
||||
OptionalShortCircuit,
|
||||
PromiseCapabilityFunction,
|
||||
PromiseInstanceMethodReference,
|
||||
PromiseMethodReference,
|
||||
type PromiseMethodName,
|
||||
PromiseNamespace,
|
||||
@@ -56,7 +57,7 @@ import {
|
||||
} from "./model.js"
|
||||
import { arrayMethods, mapMethods, setMethods, spreadItems } from "../stdlib/collections.js"
|
||||
import { consoleMethods, MAX_CONSOLE_DEPTH } from "../stdlib/console.js"
|
||||
import { dateMethods, dateStatics, invokeDateMethod, invokeDateStatic } from "../stdlib/date.js"
|
||||
import { dateMethods, invokeDateMethod, invokeDateStatic } from "../stdlib/date.js"
|
||||
import { invokeJsonMethod } from "../stdlib/json.js"
|
||||
import { invokeMathMethod, mathConstants } from "../stdlib/math.js"
|
||||
import {
|
||||
@@ -82,7 +83,6 @@ import {
|
||||
urlMethods,
|
||||
urlProperties,
|
||||
urlSearchParamsMethods,
|
||||
urlStatics,
|
||||
urlWritableProperties,
|
||||
invokeUriFunction,
|
||||
invokeURLMethod,
|
||||
@@ -95,6 +95,7 @@ import {
|
||||
coerceToNumber,
|
||||
coerceToString,
|
||||
compoundOperators,
|
||||
createAggregateErrorValue,
|
||||
createErrorValue,
|
||||
errorBrandName,
|
||||
errorConstructors,
|
||||
@@ -219,6 +220,41 @@ const normalizeError = (error: unknown): Diagnostic => {
|
||||
}
|
||||
}
|
||||
|
||||
// V8 parity: a combinator settles one reaction turn after the deciding member, never
|
||||
// before reactions already attached to it.
|
||||
const settleAfterTurn = <A, E, R>(body: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
|
||||
Effect.flatMap(Effect.exit(body), (exit) => Effect.andThen(Effect.yieldNow, exit))
|
||||
|
||||
const selfResolutionError = (node?: AstNode): InterpreterRuntimeError =>
|
||||
new InterpreterRuntimeError("Chaining cycle detected: a promise cannot resolve with itself.", node).as("TypeError")
|
||||
|
||||
// Short-circuit marker for Promise.any: the first fulfillment travels the error channel of
|
||||
// the flipped members so fail-fast Effect.all stops observing on it.
|
||||
class PromiseAnyFulfilled {
|
||||
constructor(readonly value: unknown) {}
|
||||
}
|
||||
|
||||
type ReactionHandler = CodeModeFunction | CoercionFunction | UriFunction | PromiseCapabilityFunction
|
||||
|
||||
// Non-callables are ignored as in JS: `.then(undefined, f)` relies on the passthrough.
|
||||
const reactionHandler = (value: unknown, method: string, node: AstNode): ReactionHandler | undefined => {
|
||||
if (
|
||||
value instanceof CodeModeFunction ||
|
||||
value instanceof CoercionFunction ||
|
||||
value instanceof UriFunction ||
|
||||
value instanceof PromiseCapabilityFunction
|
||||
) {
|
||||
return value
|
||||
}
|
||||
if (typeofValue(value) === "function") {
|
||||
throw new InterpreterRuntimeError(
|
||||
`${method} handlers must be plain functions; wrap other callables in an arrow function, e.g. (value) => tools.ns.tool(value).`,
|
||||
node,
|
||||
)
|
||||
}
|
||||
return undefined
|
||||
}
|
||||
|
||||
// Shared by catch bindings and Promise.allSettled rejection reasons.
|
||||
const caughtErrorValue = (thrown: unknown): unknown => {
|
||||
if (thrown instanceof ProgramThrow) return thrown.value
|
||||
@@ -227,6 +263,21 @@ const caughtErrorValue = (thrown: unknown): unknown => {
|
||||
return createErrorValue(name, normalizeError(thrown).message)
|
||||
}
|
||||
|
||||
// `new Error("msg")` and the no-new call form share this; AggregateError alone takes
|
||||
// (errors, message?) with a required errors collection, as in JS.
|
||||
const constructErrorValue = (name: string, args: Array<unknown>, node: AstNode): SafeObject => {
|
||||
if (name !== "AggregateError") return createErrorValue(name, args[0] === undefined ? "" : coerceToString(args[0]))
|
||||
const errors = spreadItems(args[0])
|
||||
if (errors === undefined) {
|
||||
throw new InterpreterRuntimeError(
|
||||
"new AggregateError(...) expects an array of errors (e.g. new AggregateError(errors, message?)).",
|
||||
node,
|
||||
).as("TypeError")
|
||||
}
|
||||
// Copy: spreadItems returns array input itself, and the error value must not alias caller data.
|
||||
return createAggregateErrorValue([...errors], args[1] === undefined ? "" : coerceToString(args[1]))
|
||||
}
|
||||
|
||||
const isRuntimeReference = (value: unknown): boolean =>
|
||||
value instanceof CodeModeFunction ||
|
||||
value instanceof ToolReference ||
|
||||
@@ -235,9 +286,11 @@ const isRuntimeReference = (value: unknown): boolean =>
|
||||
value instanceof GlobalMethodReference ||
|
||||
value instanceof PromiseNamespace ||
|
||||
value instanceof PromiseMethodReference ||
|
||||
value instanceof PromiseInstanceMethodReference ||
|
||||
value instanceof SandboxPromise ||
|
||||
value instanceof CoercionFunction ||
|
||||
value instanceof UriFunction ||
|
||||
value instanceof PromiseCapabilityFunction ||
|
||||
value instanceof ErrorConstructorReference ||
|
||||
isSandboxValue(value)
|
||||
|
||||
@@ -279,7 +332,9 @@ const typeofValue = (value: unknown): string => {
|
||||
value instanceof IntrinsicReference ||
|
||||
value instanceof GlobalMethodReference ||
|
||||
value instanceof PromiseMethodReference ||
|
||||
value instanceof PromiseInstanceMethodReference ||
|
||||
value instanceof PromiseNamespace ||
|
||||
value instanceof PromiseCapabilityFunction ||
|
||||
value instanceof ErrorConstructorReference
|
||||
)
|
||||
return "function"
|
||||
@@ -391,7 +446,7 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
|
||||
break
|
||||
}
|
||||
if (args[0] instanceof SandboxRegExp) {
|
||||
result = value.split((args[0] as SandboxRegExp).regex, optNum(1))
|
||||
result = value.split(args[0].regex, optNum(1))
|
||||
break
|
||||
}
|
||||
const requestedLimit = optNum(1)
|
||||
@@ -419,7 +474,7 @@ const invokeStringMethod = (value: string, name: string, args: Array<unknown>, n
|
||||
case "replace":
|
||||
case "replaceAll": {
|
||||
if (args[0] instanceof SandboxRegExp) {
|
||||
const pattern = (args[0] as SandboxRegExp).regex
|
||||
const pattern = args[0].regex
|
||||
const replacement = str(1)
|
||||
if (name === "replaceAll" && !pattern.global) {
|
||||
throw new InterpreterRuntimeError(
|
||||
@@ -524,9 +579,8 @@ const invokeArrayStatic = (name: string, args: Array<unknown>, node: AstNode): u
|
||||
)
|
||||
}
|
||||
// Map/Set materialize directly (the data checkpoint would serialize them to {}).
|
||||
if (args[0] instanceof SandboxMap)
|
||||
return Array.from((args[0] as SandboxMap).map.entries(), ([key, item]) => [key, item])
|
||||
if (args[0] instanceof SandboxSet) return Array.from((args[0] as SandboxSet).set.values())
|
||||
if (args[0] instanceof SandboxMap) return Array.from(args[0].map.entries(), ([key, item]) => [key, item])
|
||||
if (args[0] instanceof SandboxSet) return Array.from(args[0].set.values())
|
||||
if (args[0] instanceof SandboxURLSearchParams) {
|
||||
return Array.from(args[0].params.entries(), ([key, value]) => [key, value])
|
||||
}
|
||||
@@ -568,11 +622,7 @@ const invokeGlobalMethod = (ref: GlobalMethodReference, args: Array<unknown>, no
|
||||
if (ref.namespace === "Number") return invokeNumberStatic(ref.name, args, node)
|
||||
if (ref.namespace === "String") return invokeStringStatic(ref.name, args, node)
|
||||
if (ref.namespace === "URL") return invokeURLStatic(ref.name, args, node)
|
||||
if (ref.namespace === "Date") {
|
||||
if (!dateStatics.has(ref.name))
|
||||
throw new InterpreterRuntimeError(`Date.${ref.name} is not available in CodeMode.`, node)
|
||||
return invokeDateStatic(ref.name, args, node)
|
||||
}
|
||||
if (ref.namespace === "Date") return invokeDateStatic(ref.name, args, node)
|
||||
if (
|
||||
ref.namespace === "RegExp" ||
|
||||
ref.namespace === "Map" ||
|
||||
@@ -768,7 +818,6 @@ class Interpreter<R> {
|
||||
if (result.kind === "break" || result.kind === "continue") {
|
||||
throw new InterpreterRuntimeError(`Unexpected '${result.kind}' outside of a loop.`, statement)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// The program body runs inside an implicit async function, so a returned promise
|
||||
@@ -794,16 +843,14 @@ class Interpreter<R> {
|
||||
return this.promises.create(effect)
|
||||
}
|
||||
|
||||
// `await promise`: succeed with the fulfilled value or re-raise the failure so try/catch
|
||||
// observes it exactly like a synchronous throw at the await site. Settlement is idempotent
|
||||
// (fiber exits replay), so awaiting the same promise repeatedly never re-runs the call.
|
||||
// Settlement is idempotent (fiber exits replay), so awaiting the same promise repeatedly
|
||||
// never re-runs the call. The post-settlement yield defers the continuation one reaction
|
||||
// turn, as in JS: awaiters never resume inline, so they interleave in attach order.
|
||||
private settlePromise(promise: SandboxPromise): Effect.Effect<unknown, unknown, never> {
|
||||
const promises = this.promises
|
||||
return Effect.suspend(() => {
|
||||
promises.markObserved(promise)
|
||||
return Effect.flatMap(promises.await(promise), (exit) =>
|
||||
Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause),
|
||||
)
|
||||
return Effect.flatMap(promises.await(promise), (exit) => Effect.andThen(Effect.yieldNow, exit))
|
||||
})
|
||||
}
|
||||
|
||||
@@ -980,7 +1027,6 @@ class Interpreter<R> {
|
||||
if (result.kind === "return") {
|
||||
return result
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
return { kind: "none" } satisfies StatementResult
|
||||
@@ -1007,7 +1053,6 @@ class Interpreter<R> {
|
||||
if (result.kind === "return") {
|
||||
return result
|
||||
}
|
||||
|
||||
} while (yield* self.evaluateExpression(testNode))
|
||||
|
||||
return { kind: "none" } satisfies StatementResult
|
||||
@@ -1037,16 +1082,13 @@ class Interpreter<R> {
|
||||
: []
|
||||
|
||||
while (testNode ? yield* self.evaluateExpression(testNode) : true) {
|
||||
let iterationScope: Map<string, Binding> | undefined
|
||||
if (perIterationBindings.length > 0) {
|
||||
iterationScope = new Map(
|
||||
perIterationBindings.map((name) => {
|
||||
const binding = self.currentScope().get(name)!
|
||||
return [name, { ...binding }]
|
||||
}),
|
||||
)
|
||||
self.scopes.push(iterationScope)
|
||||
}
|
||||
const iterationScope =
|
||||
perIterationBindings.length > 0
|
||||
? new Map(
|
||||
perIterationBindings.map((name): [string, Binding] => [name, { ...self.currentScope().get(name)! }]),
|
||||
)
|
||||
: undefined
|
||||
if (iterationScope) self.scopes.push(iterationScope)
|
||||
const result = yield* self.evaluateStatement(bodyNode).pipe(
|
||||
Effect.ensuring(
|
||||
Effect.sync(() => {
|
||||
@@ -1096,7 +1138,7 @@ class Interpreter<R> {
|
||||
|
||||
// Arrays iterate in place; strings iterate code points; Maps iterate [key, value]
|
||||
// pairs and Sets iterate values over a snapshot (mutation during iteration is safe).
|
||||
const iterable = Array.isArray(right) ? right : spreadItems(right)
|
||||
const iterable = spreadItems(right)
|
||||
if (iterable === undefined) {
|
||||
throw new InterpreterRuntimeError("for...of requires an array, string, Map, or Set value in CodeMode.", node)
|
||||
}
|
||||
@@ -1550,11 +1592,10 @@ class Interpreter<R> {
|
||||
case "UpdateExpression":
|
||||
return this.evaluateUpdateExpression(node)
|
||||
case "AwaitExpression": {
|
||||
// `await` resolves a promise value; awaiting anything else is a passthrough no-op,
|
||||
// matching real JS semantics for non-thenables.
|
||||
// In JS every await suspends, even on a non-promise.
|
||||
const self = this
|
||||
return Effect.flatMap(this.evaluateExpression(getNode(node, "argument")), (value) =>
|
||||
value instanceof SandboxPromise ? self.settlePromise(value) : Effect.succeed(value),
|
||||
value instanceof SandboxPromise ? self.settlePromise(value) : Effect.as(Effect.yieldNow, value),
|
||||
)
|
||||
}
|
||||
case "NewExpression":
|
||||
@@ -1573,19 +1614,10 @@ class Interpreter<R> {
|
||||
const argNodes = getArray(node, "arguments")
|
||||
const self = this
|
||||
if (name === "Promise") {
|
||||
throw new InterpreterRuntimeError(
|
||||
"new Promise(...) is not supported in CodeMode; tool calls already return promises - call the tool and await the result.",
|
||||
node,
|
||||
"UnsupportedSyntax",
|
||||
[supportedSyntaxMessage],
|
||||
)
|
||||
return Effect.flatMap(this.evaluateCallArguments(argNodes), (args) => self.constructPromise(args[0], node))
|
||||
}
|
||||
if (errorConstructors.has(name)) {
|
||||
return Effect.gen(function* () {
|
||||
const arg =
|
||||
argNodes.length > 0 ? yield* self.evaluateExpression(asNode(argNodes[0], "arguments[0]")) : undefined
|
||||
return createErrorValue(name, arg === undefined ? "" : coerceToString(arg))
|
||||
})
|
||||
return Effect.map(this.evaluateCallArguments(argNodes), (args) => constructErrorValue(name, args, node))
|
||||
}
|
||||
if (valueConstructors.has(name)) {
|
||||
return Effect.gen(function* () {
|
||||
@@ -1923,7 +1955,7 @@ class Interpreter<R> {
|
||||
return self.setIdentifierValue(name, next, left)
|
||||
}
|
||||
const rightValue = yield* self.evaluateExpression(getNode(node, "right"))
|
||||
if (operator === "=") return self.setIdentifierValue(name, rightValue, left)
|
||||
return self.setIdentifierValue(name, rightValue, left)
|
||||
}
|
||||
if (left.type === "MemberExpression") {
|
||||
return yield* self.modifyMember(left, (current) =>
|
||||
@@ -2025,6 +2057,9 @@ class Interpreter<R> {
|
||||
if (callable instanceof PromiseMethodReference) {
|
||||
return yield* self.invokePromiseMethod(callable, args, node)
|
||||
}
|
||||
if (callable instanceof PromiseInstanceMethodReference) {
|
||||
return yield* self.invokePromiseInstanceMethod(callable, args, node)
|
||||
}
|
||||
if (callable instanceof CodeModeFunction) {
|
||||
return yield* self.invokeFunction(callable, args)
|
||||
}
|
||||
@@ -2052,7 +2087,11 @@ class Interpreter<R> {
|
||||
}
|
||||
// `Error("msg")` without `new` constructs an error exactly like `new Error("msg")`, as in JS.
|
||||
if (callable instanceof ErrorConstructorReference) {
|
||||
return createErrorValue(callable.name, args[0] === undefined ? "" : coerceToString(args[0]))
|
||||
return constructErrorValue(callable.name, args, node)
|
||||
}
|
||||
if (callable instanceof PromiseCapabilityFunction) {
|
||||
callable.settle(args[0])
|
||||
return undefined
|
||||
}
|
||||
throw new InterpreterRuntimeError("Only tools are callable in CodeMode.", callee)
|
||||
})
|
||||
@@ -2241,17 +2280,19 @@ class Interpreter<R> {
|
||||
return this.createPromise(Effect.fail(new ProgramThrow(args[0])))
|
||||
}
|
||||
|
||||
const items = Array.isArray(args[0]) ? args[0] : spreadItems(args[0])
|
||||
if (items === undefined) {
|
||||
const spread = spreadItems(args[0])
|
||||
if (spread === undefined) {
|
||||
return this.createPromise(
|
||||
Effect.fail(
|
||||
new InterpreterRuntimeError(
|
||||
`Promise.${ref.name} expects an array of promises or plain values (e.g. Promise.${ref.name}(items.map((item) => tools.ns.tool(item)))).`,
|
||||
node,
|
||||
),
|
||||
).as("TypeError"),
|
||||
),
|
||||
)
|
||||
}
|
||||
// Densify: JS combinator iteration reads sparse holes as undefined members; .map would skip them.
|
||||
const items = Array.from(spread)
|
||||
|
||||
// JS makes combinator members "handled" synchronously at the call - their rejections
|
||||
// belong to the aggregate from this moment, even ones settling before it runs.
|
||||
@@ -2261,47 +2302,42 @@ class Interpreter<R> {
|
||||
|
||||
switch (ref.name) {
|
||||
case "all": {
|
||||
// Each observation re-raises its member's failure, so Effect.all rejects on the first
|
||||
// failure without waiting for the rest and preserves input order when all fulfill.
|
||||
// Its failure-time interruption only unsubscribes the sibling waiters: the underlying
|
||||
// fibers stay execution-owned and keep running, as in JS.
|
||||
// Rejects on the first failure; sibling fibers stay execution-owned and keep running, as in JS.
|
||||
const observations = items.map((item) =>
|
||||
item instanceof SandboxPromise
|
||||
? Effect.flatMap(this.promises.await(item), (exit) =>
|
||||
Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause),
|
||||
)
|
||||
: Effect.succeed(item),
|
||||
item instanceof SandboxPromise ? Effect.flatten(this.promises.await(item)) : Effect.succeed(item),
|
||||
)
|
||||
return this.createPromise(Effect.all(observations, { concurrency: "unbounded" }))
|
||||
return this.createPromise(settleAfterTurn(Effect.all(observations, { concurrency: "unbounded" })))
|
||||
}
|
||||
case "allSettled": {
|
||||
const observations = items.map((item) =>
|
||||
item instanceof SandboxPromise ? this.promises.await(item) : Effect.succeed(Exit.succeed(item as unknown)),
|
||||
item instanceof SandboxPromise ? this.promises.await(item) : Effect.succeed(Exit.succeed(item)),
|
||||
)
|
||||
return this.createPromise(
|
||||
Effect.gen(function* () {
|
||||
const outcomes: Array<unknown> = []
|
||||
for (const observation of observations) {
|
||||
const exit = yield* observation
|
||||
if (Exit.isSuccess(exit)) {
|
||||
settleAfterTurn(
|
||||
Effect.gen(function* () {
|
||||
const outcomes: Array<unknown> = []
|
||||
for (const observation of observations) {
|
||||
const exit = yield* observation
|
||||
if (Exit.isSuccess(exit)) {
|
||||
outcomes.push(
|
||||
Object.assign(Object.create(null) as SafeObject, { status: "fulfilled", value: exit.value }),
|
||||
)
|
||||
continue
|
||||
}
|
||||
if (Cause.hasInterruptsOnly(exit.cause)) {
|
||||
// Execution teardown (timeout/host interruption), not a program-level rejection.
|
||||
return yield* Effect.failCause(exit.cause)
|
||||
}
|
||||
outcomes.push(
|
||||
Object.assign(Object.create(null) as SafeObject, { status: "fulfilled", value: exit.value }),
|
||||
Object.assign(Object.create(null) as SafeObject, {
|
||||
status: "rejected",
|
||||
reason: caughtErrorValue(Cause.squash(exit.cause)),
|
||||
}),
|
||||
)
|
||||
continue
|
||||
}
|
||||
if (Cause.hasInterruptsOnly(exit.cause)) {
|
||||
// Execution teardown (timeout/host interruption), not a program-level rejection.
|
||||
return yield* Effect.failCause(exit.cause)
|
||||
}
|
||||
outcomes.push(
|
||||
Object.assign(Object.create(null) as SafeObject, {
|
||||
status: "rejected",
|
||||
reason: caughtErrorValue(Cause.squash(exit.cause)),
|
||||
}),
|
||||
)
|
||||
}
|
||||
return outcomes
|
||||
}),
|
||||
return outcomes
|
||||
}),
|
||||
),
|
||||
)
|
||||
}
|
||||
case "race": {
|
||||
@@ -2316,19 +2352,146 @@ class Interpreter<R> {
|
||||
)
|
||||
}
|
||||
const observations = items.map((item) =>
|
||||
item instanceof SandboxPromise ? this.promises.await(item) : Effect.succeed(Exit.succeed(item as unknown)),
|
||||
item instanceof SandboxPromise ? this.promises.await(item) : Effect.succeed(Exit.succeed(item)),
|
||||
)
|
||||
// First settlement (fulfilled OR rejected) wins; losing work stays execution-owned
|
||||
// and is interrupted at normal completion (already observed) or by teardown.
|
||||
return this.createPromise(
|
||||
Effect.flatMap(Effect.raceAll(observations), (exit) =>
|
||||
Exit.isSuccess(exit) ? Effect.succeed(exit.value) : Effect.failCause(exit.cause),
|
||||
return this.createPromise(settleAfterTurn(Effect.flatten(Effect.raceAll(observations))))
|
||||
}
|
||||
case "any": {
|
||||
// De Morgan dual of Promise.all: members are flipped so the first fulfillment
|
||||
// short-circuits fail-fast Effect.all, and all-rejected completes with the reasons
|
||||
// in input order for the AggregateError.
|
||||
const flipped = items.map((item) =>
|
||||
item instanceof SandboxPromise
|
||||
? Effect.flatMap(this.promises.await(item), (exit) => {
|
||||
if (Exit.isSuccess(exit)) return Effect.fail(new PromiseAnyFulfilled(exit.value))
|
||||
if (Cause.hasInterruptsOnly(exit.cause)) return Effect.failCause(exit.cause)
|
||||
return Effect.succeed(caughtErrorValue(Cause.squash(exit.cause)))
|
||||
})
|
||||
: Effect.fail(new PromiseAnyFulfilled(item)),
|
||||
)
|
||||
const body = Effect.all(flipped, { concurrency: "unbounded" }).pipe(
|
||||
Effect.flatMap((reasons) =>
|
||||
Effect.fail(new ProgramThrow(createAggregateErrorValue(reasons, "All promises were rejected"))),
|
||||
),
|
||||
Effect.catch((error) =>
|
||||
error instanceof PromiseAnyFulfilled ? Effect.succeed(error.value) : Effect.fail(error),
|
||||
),
|
||||
)
|
||||
return this.createPromise(settleAfterTurn(body))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Teardown interruption propagates without running handlers; a real settlement defers
|
||||
// one reaction turn so handlers never run inline.
|
||||
private reactionExit(source: SandboxPromise): Effect.Effect<Exit.Exit<unknown, unknown>, unknown, R> {
|
||||
const promises = this.promises
|
||||
return Effect.gen(function* () {
|
||||
const exit = yield* promises.await(source)
|
||||
if (!Exit.isSuccess(exit) && Cause.hasInterruptsOnly(exit.cause)) return yield* Effect.failCause(exit.cause)
|
||||
yield* Effect.yieldNow
|
||||
return exit
|
||||
})
|
||||
}
|
||||
|
||||
private invokePromiseInstanceMethod(
|
||||
ref: PromiseInstanceMethodReference,
|
||||
args: Array<unknown>,
|
||||
node: AstNode,
|
||||
): Effect.Effect<SandboxPromise, never, R> {
|
||||
const method = `Promise.prototype.${ref.name}`
|
||||
this.promises.markObserved(ref.promise)
|
||||
if (ref.name === "finally") {
|
||||
return this.chainFinally(ref.promise, reactionHandler(args[0], method, node), method, node)
|
||||
}
|
||||
const onFulfilled = ref.name === "then" ? reactionHandler(args[0], method, node) : undefined
|
||||
const onRejected = reactionHandler(ref.name === "then" ? args[1] : args[0], method, node)
|
||||
return this.chainReaction(ref.promise, onFulfilled, onRejected, method, node)
|
||||
}
|
||||
|
||||
private chainReaction(
|
||||
source: SandboxPromise,
|
||||
onFulfilled: ReactionHandler | undefined,
|
||||
onRejected: ReactionHandler | undefined,
|
||||
method: string,
|
||||
node: AstNode,
|
||||
): Effect.Effect<SandboxPromise, never, R> {
|
||||
const self = this
|
||||
const box: { derived?: SandboxPromise } = {}
|
||||
const body = Effect.gen(function* () {
|
||||
const exit = yield* self.reactionExit(source)
|
||||
const handler = Exit.isSuccess(exit) ? onFulfilled : onRejected
|
||||
if (handler === undefined) return yield* exit
|
||||
const input = Exit.isSuccess(exit) ? exit.value : caughtErrorValue(Cause.squash(exit.cause))
|
||||
const result = yield* self.applyCollectionCallback(handler, method, node)([input])
|
||||
if (result === box.derived) return yield* Effect.fail(selfResolutionError(node))
|
||||
if (result instanceof SandboxPromise) return yield* self.settlePromise(result)
|
||||
return result
|
||||
})
|
||||
return Effect.map(this.createPromise(body), (derived) => {
|
||||
box.derived = derived
|
||||
return derived
|
||||
})
|
||||
}
|
||||
|
||||
private chainFinally(
|
||||
source: SandboxPromise,
|
||||
cleanup: ReactionHandler | undefined,
|
||||
method: string,
|
||||
node: AstNode,
|
||||
): Effect.Effect<SandboxPromise, never, R> {
|
||||
const self = this
|
||||
return this.createPromise(
|
||||
Effect.gen(function* () {
|
||||
const exit = yield* self.reactionExit(source)
|
||||
if (cleanup !== undefined) {
|
||||
const result = yield* self.applyCollectionCallback(cleanup, method, node)([])
|
||||
if (result instanceof SandboxPromise) yield* self.settlePromise(result)
|
||||
}
|
||||
return yield* exit
|
||||
}),
|
||||
)
|
||||
}
|
||||
|
||||
// new Promise(executor): the promise's fiber awaits a Deferred that resolve/reject settle
|
||||
// exactly once. The executor runs synchronously; its throw rejects the promise unless it
|
||||
// already settled (JS swallows post-settlement executor throws).
|
||||
private constructPromise(executor: unknown, node: AstNode): Effect.Effect<SandboxPromise, unknown, R> {
|
||||
if (!(executor instanceof CodeModeFunction)) {
|
||||
throw new InterpreterRuntimeError(
|
||||
"new Promise(...) expects an executor function (e.g. new Promise((resolve, reject) => { ... })).",
|
||||
node,
|
||||
).as("TypeError")
|
||||
}
|
||||
const self = this
|
||||
return Effect.gen(function* () {
|
||||
const deferred = Deferred.makeUnsafe<unknown, unknown>()
|
||||
const box: { own?: SandboxPromise } = {}
|
||||
const promise = yield* self.createPromise(
|
||||
Effect.flatMap(Deferred.await(deferred), (value) => {
|
||||
if (!(value instanceof SandboxPromise)) return Effect.succeed(value)
|
||||
if (value === box.own) return Effect.fail(selfResolutionError(node))
|
||||
return self.settlePromise(value)
|
||||
}),
|
||||
)
|
||||
box.own = promise
|
||||
const resolve = new PromiseCapabilityFunction((value) => {
|
||||
Deferred.doneUnsafe(deferred, Exit.succeed(value))
|
||||
})
|
||||
const reject = new PromiseCapabilityFunction((value) => {
|
||||
Deferred.doneUnsafe(deferred, Exit.fail(new ProgramThrow(value)))
|
||||
})
|
||||
const executed = yield* Effect.exit(self.invokeFunction(executor, [resolve, reject]))
|
||||
if (!Exit.isSuccess(executed)) {
|
||||
if (Cause.hasInterruptsOnly(executed.cause)) return yield* Effect.failCause(executed.cause)
|
||||
Deferred.doneUnsafe(deferred, Exit.fail(Cause.squash(executed.cause)))
|
||||
}
|
||||
return promise
|
||||
})
|
||||
}
|
||||
|
||||
private invokeFunction(fn: CodeModeFunction, args: Array<unknown>): Effect.Effect<unknown, unknown, R> {
|
||||
const invocation = new Interpreter(this.invokeTool, this.toolKeys, this.promises, this.logs, this.callPermits)
|
||||
invocation.scopes = [...fn.capturedScopes, new Map<string, Binding>()]
|
||||
@@ -2358,10 +2521,20 @@ class Interpreter<R> {
|
||||
return yield* invocation.evaluateExpression(fn.body)
|
||||
})
|
||||
if (!fn.async) return run
|
||||
return this.createPromise(
|
||||
Effect.flatMap(run, (value) =>
|
||||
value instanceof SandboxPromise ? invocation.settlePromise(value) : Effect.succeed(value),
|
||||
// Every await yields, so `box.own` is assigned before the body can return a reference to it.
|
||||
const box: { own?: SandboxPromise } = {}
|
||||
return Effect.map(
|
||||
this.createPromise(
|
||||
Effect.flatMap(run, (value) => {
|
||||
if (!(value instanceof SandboxPromise)) return Effect.succeed(value)
|
||||
if (value === box.own) return Effect.fail(selfResolutionError())
|
||||
return invocation.settlePromise(value)
|
||||
}),
|
||||
),
|
||||
(promise) => {
|
||||
box.own = promise
|
||||
return promise
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
@@ -2472,8 +2645,8 @@ class Interpreter<R> {
|
||||
})
|
||||
}
|
||||
|
||||
// Runs a collection callback accepting a user function or supported builtin callable,
|
||||
// mirroring the array-method callback contract.
|
||||
// Accepts a user function or supported builtin callable, so idioms such as
|
||||
// `filter(Boolean)`, `map(String)`, and `map(encodeURIComponent)` work as in JS.
|
||||
private applyCollectionCallback(
|
||||
callback: unknown,
|
||||
name: string,
|
||||
@@ -2482,7 +2655,8 @@ class Interpreter<R> {
|
||||
if (
|
||||
!(callback instanceof CodeModeFunction) &&
|
||||
!(callback instanceof CoercionFunction) &&
|
||||
!(callback instanceof UriFunction)
|
||||
!(callback instanceof UriFunction) &&
|
||||
!(callback instanceof PromiseCapabilityFunction)
|
||||
) {
|
||||
throw new InterpreterRuntimeError(`${name} expects a function callback.`, node)
|
||||
}
|
||||
@@ -2491,7 +2665,9 @@ class Interpreter<R> {
|
||||
? Effect.succeed(invokeCoercion(callback, callbackArgs, node))
|
||||
: callback instanceof UriFunction
|
||||
? Effect.succeed(invokeUriFunction(callback, callbackArgs, node))
|
||||
: this.invokeFunction(callback, callbackArgs)
|
||||
: callback instanceof PromiseCapabilityFunction
|
||||
? Effect.sync(() => callback.settle(callbackArgs[0]))
|
||||
: this.invokeFunction(callback, callbackArgs)
|
||||
}
|
||||
|
||||
private invokeMapMethod(
|
||||
@@ -2761,24 +2937,7 @@ class Interpreter<R> {
|
||||
return Effect.succeed(Array.from(target.entries(), ([index, item]): Array<unknown> => [index, item]))
|
||||
}
|
||||
|
||||
const callback = args[0]
|
||||
if (
|
||||
!(callback instanceof CodeModeFunction) &&
|
||||
!(callback instanceof CoercionFunction) &&
|
||||
!(callback instanceof UriFunction)
|
||||
) {
|
||||
throw new InterpreterRuntimeError(`Array.${name} expects a function callback.`, node)
|
||||
}
|
||||
const self = this
|
||||
// Accept a user function or supported builtin callable, so idioms such as
|
||||
// `filter(Boolean)`, `map(String)`, and `map(encodeURIComponent)` work as in JS. Builtins
|
||||
// are synchronous; only CodeModeFunctions can await tool calls.
|
||||
const apply = (callbackArgs: Array<unknown>): Effect.Effect<unknown, unknown, R> =>
|
||||
callback instanceof CoercionFunction
|
||||
? Effect.succeed(invokeCoercion(callback, callbackArgs, node))
|
||||
: callback instanceof UriFunction
|
||||
? Effect.succeed(invokeUriFunction(callback, callbackArgs, node))
|
||||
: self.invokeFunction(callback, callbackArgs)
|
||||
const apply = this.applyCollectionCallback(args[0], `Array.${name}`, node)
|
||||
return Effect.gen(function* () {
|
||||
// Capture the initial length, but read the receiver live so callbacks observe mutations
|
||||
// without visiting elements appended after iteration begins.
|
||||
@@ -3079,6 +3238,7 @@ class Interpreter<R> {
|
||||
| MemberReference
|
||||
| ToolReference
|
||||
| PromiseMethodReference
|
||||
| PromiseInstanceMethodReference
|
||||
| IntrinsicReference
|
||||
| GlobalMethodReference
|
||||
| ComputedValue
|
||||
@@ -3115,7 +3275,7 @@ class Interpreter<R> {
|
||||
return new PromiseMethodReference(key as PromiseMethodName)
|
||||
}
|
||||
throw new InterpreterRuntimeError(
|
||||
`Promise.${String(key)} is not available in CodeMode. Available: Promise.all, Promise.allSettled, Promise.race, Promise.resolve, and Promise.reject; consume promises with await.`,
|
||||
`Promise.${String(key)} is not available in CodeMode. Available: Promise.all, Promise.allSettled, Promise.race, Promise.any, Promise.resolve, and Promise.reject; consume promises with await.`,
|
||||
propertyNode,
|
||||
)
|
||||
}
|
||||
@@ -3199,20 +3359,13 @@ class Interpreter<R> {
|
||||
return new ComputedValue(undefined)
|
||||
}
|
||||
|
||||
// Any property access on a promise is a confused program (`p.then(...)`, `p.value`);
|
||||
// reading `undefined` here would hide the missing await, so both paths get an explicit,
|
||||
// await-hinting error instead of the forgiving unknown-property fallthrough.
|
||||
// Error instead of `undefined` so a missing await never hides.
|
||||
if (objectValue instanceof SandboxPromise) {
|
||||
if (key === "then" || key === "catch" || key === "finally") {
|
||||
throw new InterpreterRuntimeError(
|
||||
`Promise.prototype.${String(key)} is not supported in CodeMode; use await instead (with try/catch to handle failures) - e.g. \`const result = await tools.ns.tool(...)\`.`,
|
||||
propertyNode,
|
||||
"UnsupportedSyntax",
|
||||
[supportedSyntaxMessage],
|
||||
)
|
||||
return new PromiseInstanceMethodReference(objectValue, key)
|
||||
}
|
||||
throw new InterpreterRuntimeError(
|
||||
"This value is an un-awaited Promise and has no readable properties; await it first - e.g. `const result = await tools.ns.tool(...)`.",
|
||||
"This value is an un-awaited Promise; await it first - e.g. `const result = await tools.ns.tool(...)`.",
|
||||
objectNode,
|
||||
"InvalidDataValue",
|
||||
)
|
||||
@@ -3265,6 +3418,7 @@ class Interpreter<R> {
|
||||
reference === undefined ||
|
||||
reference instanceof ToolReference ||
|
||||
reference instanceof PromiseMethodReference ||
|
||||
reference instanceof PromiseInstanceMethodReference ||
|
||||
reference instanceof IntrinsicReference ||
|
||||
reference instanceof GlobalMethodReference
|
||||
)
|
||||
@@ -3302,6 +3456,7 @@ class Interpreter<R> {
|
||||
reference === undefined ||
|
||||
reference instanceof ToolReference ||
|
||||
reference instanceof PromiseMethodReference ||
|
||||
reference instanceof PromiseInstanceMethodReference ||
|
||||
reference instanceof IntrinsicReference ||
|
||||
reference instanceof GlobalMethodReference
|
||||
) {
|
||||
@@ -3489,15 +3644,14 @@ export const executeWithLimits = <const Tools extends Record<string, unknown>>(
|
||||
// and the timeout path's completed value - binds at run time: a reused Effect must start
|
||||
// from a clean slate instead of observing a previous run's state.
|
||||
return Effect.suspend(() => {
|
||||
const hooks = {
|
||||
...(options.onToolCallStart === undefined ? {} : { onToolCallStart: options.onToolCallStart }),
|
||||
...(options.onToolCallEnd === undefined ? {} : { onToolCallEnd: options.onToolCallEnd }),
|
||||
}
|
||||
const tools = ToolRuntime.make(
|
||||
(options.tools ?? {}) as HostTools<Services<Tools>>,
|
||||
limits.maxToolCalls,
|
||||
searchIndex,
|
||||
hooks,
|
||||
{
|
||||
onToolCallStart: options.onToolCallStart,
|
||||
onToolCallEnd: options.onToolCallEnd,
|
||||
},
|
||||
)
|
||||
const logs: Array<string> = []
|
||||
const logged = () => (logs.length > 0 ? { logs: [...logs] } : {})
|
||||
|
||||
@@ -46,9 +46,7 @@ export const invoke = (plan: Plan, input: unknown): Effect.Effect<unknown, unkno
|
||||
)
|
||||
}
|
||||
if (json && Option.isNone(decoded)) {
|
||||
return yield* Effect.fail(
|
||||
toolError(`${plan.operation.method} ${plan.operation.path} returned malformed JSON.`),
|
||||
)
|
||||
return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} returned malformed JSON.`))
|
||||
}
|
||||
return parsed
|
||||
})
|
||||
@@ -208,8 +206,9 @@ const buildUrl = (plan: Plan, input: Readonly<Record<string, unknown>>): string
|
||||
return toolError(`Missing required path parameter '${field.inputName}'.`)
|
||||
}
|
||||
const fieldValue = serializeSimple(field, item, (value) =>
|
||||
encodeURIComponent(value).replace(/[!'()*]/g, (character) =>
|
||||
`%${character.charCodeAt(0).toString(16).toUpperCase()}`,
|
||||
encodeURIComponent(value).replace(
|
||||
/[!'()*]/g,
|
||||
(character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`,
|
||||
),
|
||||
)
|
||||
if (fieldValue instanceof ToolError) return fieldValue
|
||||
@@ -271,10 +270,7 @@ const serializeQuery = (
|
||||
if (value.some((item) => item === undefined || (item !== null && typeof item === "object"))) {
|
||||
return toolError(`Query parameter '${field.inputName}' contains an unsupported nested value.`)
|
||||
}
|
||||
return value.reduce(
|
||||
(current, item) => HttpClientRequest.appendUrlParam(current, field.name, String(item)),
|
||||
request,
|
||||
)
|
||||
return value.reduce((current, item) => HttpClientRequest.appendUrlParam(current, field.name, String(item)), request)
|
||||
}
|
||||
if (isRecord(value) && field.explode) {
|
||||
return Object.entries(value).reduce<HttpClientRequest.HttpClientRequest | ToolError>((current, [name, item]) => {
|
||||
@@ -289,11 +285,15 @@ const serializeQuery = (
|
||||
return rendered instanceof ToolError ? rendered : HttpClientRequest.appendUrlParam(request, field.name, rendered)
|
||||
}
|
||||
|
||||
const readResponseBody = (response: HttpClientResponse.HttpClientResponse, plan: Plan): Effect.Effect<string, ToolError> =>
|
||||
const readResponseBody = (
|
||||
response: HttpClientResponse.HttpClientResponse,
|
||||
plan: Plan,
|
||||
): Effect.Effect<string, ToolError> =>
|
||||
Effect.gen(function* () {
|
||||
const contentLength = response.headers["content-length"]
|
||||
const parsedSize = contentLength === undefined ? undefined : Number.parseInt(contentLength, 10)
|
||||
const declaredSize = parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined
|
||||
const declaredSize =
|
||||
parsedSize !== undefined && Number.isSafeInteger(parsedSize) && parsedSize >= 0 ? parsedSize : undefined
|
||||
if (declaredSize !== undefined && declaredSize > maxResponseBodyBytes) {
|
||||
return yield* Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
|
||||
}
|
||||
@@ -304,7 +304,9 @@ const readResponseBody = (response: HttpClientResponse.HttpClientResponse, plan:
|
||||
return Effect.fail(toolError(`${plan.operation.method} ${plan.operation.path} response exceeds 50 MiB.`))
|
||||
}
|
||||
if (size + chunk.byteLength > body.byteLength) {
|
||||
const grown = Buffer.allocUnsafe(Math.min(maxResponseBodyBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)))
|
||||
const grown = Buffer.allocUnsafe(
|
||||
Math.min(maxResponseBodyBytes, Math.max(size + chunk.byteLength, body.byteLength * 2)),
|
||||
)
|
||||
body.copy(grown, 0, 0, size)
|
||||
body = grown
|
||||
}
|
||||
|
||||
@@ -78,7 +78,9 @@ const isBinaryMediaType = (document: Document, mediaType: string, value: unknown
|
||||
return isRecord(schema) && schema.format === "binary"
|
||||
}
|
||||
|
||||
const jsonContent = (content: Record<string, unknown>): { readonly mediaType: string; readonly schema: unknown } | undefined => {
|
||||
const jsonContent = (
|
||||
content: Record<string, unknown>,
|
||||
): { readonly mediaType: string; readonly schema: unknown } | undefined => {
|
||||
const entry = Object.entries(content).find(([mediaType]) => isJsonMediaType(mediaType))
|
||||
return entry !== undefined && isRecord(entry[1]) ? { mediaType: entry[0], schema: entry[1].schema } : undefined
|
||||
}
|
||||
@@ -344,7 +346,7 @@ export const operationOutput = (
|
||||
if (outcomes.length === 0) return { ok: true, value: undefined }
|
||||
return {
|
||||
ok: true,
|
||||
value: withDefinitions(outcomes.length === 1 ? outcomes[0] ?? {} : { anyOf: outcomes }, definitions),
|
||||
value: withDefinitions(outcomes.length === 1 ? (outcomes[0] ?? {}) : { anyOf: outcomes }, definitions),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -380,7 +382,9 @@ export const operationPath = (
|
||||
namespaces: ReadonlySet<string>,
|
||||
): ReadonlyArray<string> => {
|
||||
const raw = nonEmptyString(operation.operationId)
|
||||
const segments = (raw === undefined ? [fallbackOperationId(method, path)] : raw.split(".")).map(sanitizeOperationSegment)
|
||||
const segments = (raw === undefined ? [fallbackOperationId(method, path)] : raw.split(".")).map(
|
||||
sanitizeOperationSegment,
|
||||
)
|
||||
if (isOperationPathAvailable(segments, used, namespaces)) return segments
|
||||
const conflict = segments.slice(0, -1).findIndex((_, index) => used.has(segments.slice(0, index + 1).join(".")))
|
||||
if (conflict >= 0 && conflict + 1 < segments.length) {
|
||||
|
||||
@@ -23,8 +23,6 @@ export const dateMethods = new Set([
|
||||
"getTimezoneOffset",
|
||||
])
|
||||
|
||||
export const dateStatics = new Set(["now", "parse", "UTC"])
|
||||
|
||||
export const invokeDateStatic = (name: string, args: Array<unknown>, node: AstNode): number => {
|
||||
switch (name) {
|
||||
case "now":
|
||||
|
||||
@@ -6,10 +6,7 @@ import {
|
||||
} from "../interpreter/model.js"
|
||||
import { copyIn, copyOut } from "../tool-runtime.js"
|
||||
|
||||
export const jsonStatics = new Set(["stringify", "parse"])
|
||||
|
||||
export const invokeJsonMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
|
||||
if (!jsonStatics.has(name)) throw new InterpreterRuntimeError(`JSON.${name} is not available in CodeMode.`, node)
|
||||
switch (name) {
|
||||
case "stringify": {
|
||||
const replacer = args[1]
|
||||
|
||||
@@ -3,11 +3,9 @@ import { isBlockedMember } from "../tool-runtime.js"
|
||||
import { isSandboxValue, SandboxMap, SandboxPromise, SandboxSet, SandboxURLSearchParams } from "../values.js"
|
||||
import { boundedData, coerceToString } from "./value.js"
|
||||
|
||||
export const objectStatics = new Set(["keys", "values", "entries", "hasOwn", "assign", "fromEntries"])
|
||||
export const objectMethodsPreservingIdentity = new Set(["assign", "values", "entries", "fromEntries"])
|
||||
|
||||
export const invokeObjectMethod = (name: string, args: Array<unknown>, node: AstNode): unknown => {
|
||||
if (!objectStatics.has(name)) throw new InterpreterRuntimeError(`Object.${name} is not available in CodeMode.`, node)
|
||||
const requireObject = (): Record<string, unknown> => {
|
||||
const input = args[0]
|
||||
if (Array.isArray(input)) return input as unknown as Record<string, unknown>
|
||||
@@ -53,13 +51,11 @@ export const invokeObjectMethod = (name: string, args: Array<unknown>, node: Ast
|
||||
}
|
||||
const out = target as Record<string, unknown>
|
||||
for (const source of args.slice(1)) {
|
||||
if (source === null || source === undefined) continue
|
||||
const value = source
|
||||
if (isSandboxValue(value)) continue
|
||||
if (value === null || typeof value !== "object" || Array.isArray(value)) {
|
||||
if (source === null || source === undefined || isSandboxValue(source)) continue
|
||||
if (typeof source !== "object" || Array.isArray(source)) {
|
||||
throw new InterpreterRuntimeError("Object.assign expects data objects.", node)
|
||||
}
|
||||
for (const [key, item] of Object.entries(value)) guardedSet(out, key, item)
|
||||
for (const [key, item] of Object.entries(source)) guardedSet(out, key, item)
|
||||
}
|
||||
return out
|
||||
}
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import type { PromiseMethodName } from "../interpreter/model.js"
|
||||
|
||||
export const promiseStatics = new Set<PromiseMethodName>(["all", "allSettled", "race", "resolve", "reject"])
|
||||
export const promiseStatics = new Set<PromiseMethodName>(["all", "allSettled", "race", "any", "resolve", "reject"])
|
||||
|
||||
/** Maximum number of eagerly forked tool calls that may run concurrently. */
|
||||
export const TOOL_CALL_CONCURRENCY = 8
|
||||
|
||||
@@ -6,6 +6,7 @@ export const errorConstructors = new Set([
|
||||
"ReferenceError",
|
||||
"EvalError",
|
||||
"URIError",
|
||||
"AggregateError",
|
||||
])
|
||||
|
||||
export const valueConstructors = new Set(["Date", "RegExp", "Map", "Set", "URL", "URLSearchParams"])
|
||||
@@ -20,6 +21,9 @@ export const createErrorValue = (name: string, message: string): SafeObject => {
|
||||
return value
|
||||
}
|
||||
|
||||
export const createAggregateErrorValue = (errors: Array<unknown>, message: string): SafeObject =>
|
||||
Object.assign(createErrorValue("AggregateError", message), { errors })
|
||||
|
||||
export const errorBrandName = (value: unknown): string | undefined =>
|
||||
value !== null && typeof value === "object"
|
||||
? ((value as Record<PropertyKey, unknown>)[ErrorBrand] as string | undefined)
|
||||
@@ -60,7 +64,7 @@ export const invokeCoercion = (ref: CoercionFunction, args: Array<unknown>, node
|
||||
if (ref.name === "parseInt") return parseInt(coerceToString(raw))
|
||||
return parseFloat(coerceToString(raw))
|
||||
}
|
||||
const value = boundedData(args[0], `${ref.name} input`)
|
||||
const value = boundedData(raw, `${ref.name} input`)
|
||||
if (ref.name === "Number") return coerceToNumber(value)
|
||||
if (ref.name === "Boolean") return Boolean(value)
|
||||
if (ref.name === "parseInt") {
|
||||
@@ -73,11 +77,7 @@ export const invokeCoercion = (ref: CoercionFunction, args: Array<unknown>, node
|
||||
if (ref.name === "parseFloat") return parseFloat(coerceToString(value))
|
||||
return coerceToString(value)
|
||||
}
|
||||
import {
|
||||
type AstNode,
|
||||
CoercionFunction,
|
||||
InterpreterRuntimeError,
|
||||
} from "../interpreter/model.js"
|
||||
import { type AstNode, CoercionFunction, InterpreterRuntimeError } from "../interpreter/model.js"
|
||||
import { copyIn, type SafeObject } from "../tool-runtime.js"
|
||||
import {
|
||||
isSandboxValue,
|
||||
|
||||
@@ -326,15 +326,12 @@ export const copyOut = (value: unknown, undefinedAsNull = false): unknown => {
|
||||
const definitions = <R>(
|
||||
tools: HostTools<R>,
|
||||
path: ReadonlyArray<string> = [],
|
||||
): Array<{ path: string; definition: Definition<R> }> => {
|
||||
const entries: Array<{ path: string; definition: Definition<R> }> = []
|
||||
for (const [name, value] of Object.entries(tools)) {
|
||||
): Array<{ path: string; definition: Definition<R> }> =>
|
||||
Object.entries(tools).flatMap(([name, value]) => {
|
||||
const next = [...path, name]
|
||||
if (isDefinition(value)) entries.push({ path: next.join("."), definition: value })
|
||||
else if (typeof value !== "function") entries.push(...definitions(value, next))
|
||||
}
|
||||
return entries
|
||||
}
|
||||
if (isDefinition(value)) return [{ path: next.join("."), definition: value }]
|
||||
return typeof value === "function" ? [] : definitions(value, next)
|
||||
})
|
||||
|
||||
const describeDefinition = <R>(path: string, definition: Definition<R>): ToolDescription => ({
|
||||
path,
|
||||
@@ -349,9 +346,6 @@ const visibleDefinitions = <R>(tools: HostTools<R>) =>
|
||||
description: describeDefinition(path, definition),
|
||||
}))
|
||||
|
||||
export const catalog = <R>(tools: HostTools<R>): ReadonlyArray<ToolDescription> =>
|
||||
visibleDefinitions(tools).map(({ description }) => description)
|
||||
|
||||
export type DiscoveryPlan = {
|
||||
readonly catalog: ReadonlyArray<ToolDescription>
|
||||
readonly instructions: string
|
||||
@@ -617,7 +611,7 @@ export const prepare = <R>(tools: HostTools<R>, catalogBudget = defaultCatalogBu
|
||||
"## Language",
|
||||
"",
|
||||
"Use common JavaScript data operations, functions, control flow, selected standard-library methods, and awaited tool calls. Built-ins include Date, RegExp, Map, Set, URL, URLSearchParams, and URI encoding helpers.",
|
||||
"Modules/imports, classes, generators, timers, fetch, eval, prototype access, unlisted methods, and promise chaining are unavailable. Use Code Mode tools for external operations. Use await with try/catch.",
|
||||
"Modules/imports, classes, generators, timers, fetch, eval, prototype access, and unlisted methods are unavailable. Use Code Mode tools for external operations. Use await with try/catch.",
|
||||
"Prefer explicit `return`; otherwise only the final top-level expression becomes the result.",
|
||||
"Dates and URLs serialize to strings at data boundaries; Map/Set/RegExp/URLSearchParams serialize to `{}`.",
|
||||
]
|
||||
|
||||
@@ -23,7 +23,7 @@ const effectNumberSentinel = (schema: JsonSchema) =>
|
||||
const intersection = (members: ReadonlyArray<string>): string => {
|
||||
const concrete = members.filter((member) => member !== "unknown")
|
||||
if (concrete.length === 0) return "unknown"
|
||||
if (concrete.length === 1) return concrete[0] ?? "unknown"
|
||||
if (concrete.length === 1) return concrete[0]
|
||||
return concrete.map((member) => (member.includes(" | ") ? `(${member})` : member)).join(" & ")
|
||||
}
|
||||
|
||||
|
||||
@@ -672,9 +672,11 @@ describe("CodeMode public contract", () => {
|
||||
expect(instructions).toContain("not a general-purpose runtime")
|
||||
expect(instructions).not.toContain("Standard modern JavaScript works")
|
||||
expect(instructions).not.toContain("TypeScript type annotations")
|
||||
for (const missing of ["Modules/imports", "classes", "generators", "fetch", "promise chaining"]) {
|
||||
for (const missing of ["Modules/imports", "classes", "generators", "fetch"]) {
|
||||
expect(instructions).toContain(missing)
|
||||
}
|
||||
expect(instructions).not.toContain("new Promise(...) are unavailable")
|
||||
expect(instructions).not.toContain("promise chaining")
|
||||
expect(instructions).toContain("URL, URLSearchParams, and URI encoding helpers")
|
||||
expect(instructions).not.toContain("host globals")
|
||||
expect(instructions).toContain("Use Code Mode tools for external operations")
|
||||
|
||||
@@ -16,8 +16,7 @@ import { describe, expect, test } from "bun:test"
|
||||
import { Effect } from "effect"
|
||||
import { CodeMode } from "../src/index.js"
|
||||
|
||||
const execute = (code: string) =>
|
||||
Effect.runPromise(CodeMode.execute({ code, tools: {}, limits: { timeoutMs: 1_000 } }))
|
||||
const execute = (code: string) => Effect.runPromise(CodeMode.execute({ code, tools: {}, limits: { timeoutMs: 1_000 } }))
|
||||
|
||||
const value = async (code: string) => {
|
||||
const result = await execute(code)
|
||||
@@ -450,7 +449,10 @@ describe("Test262 async functions and await", () => {
|
||||
const promises = [declaration(), expression(), arrow()]
|
||||
return [promises.map((item) => item instanceof Promise), await Promise.all(promises)]
|
||||
`),
|
||||
).toEqual([[true, true, true], [1, 2, 3]])
|
||||
).toEqual([
|
||||
[true, true, true],
|
||||
[1, 2, 3],
|
||||
])
|
||||
})
|
||||
|
||||
test("async bodies adopt returns and reject throws before and after await", async () => {
|
||||
@@ -479,13 +481,7 @@ describe("Test262 async functions and await", () => {
|
||||
await observe(throwsAfter()),
|
||||
]
|
||||
`),
|
||||
).toEqual([
|
||||
["body"],
|
||||
["fulfilled", 42],
|
||||
["fulfilled", 43],
|
||||
["rejected", 1],
|
||||
["rejected", 2],
|
||||
])
|
||||
).toEqual([["body"], ["fulfilled", 42], ["fulfilled", 43], ["rejected", 1], ["rejected", 2]])
|
||||
})
|
||||
|
||||
test("default-parameter throws reject instead of escaping the call", async () => {
|
||||
@@ -577,13 +573,14 @@ describe("Test262 async functions and await", () => {
|
||||
})
|
||||
|
||||
describe("Test262 expected Promise conformance", () => {
|
||||
for (const name of ["all", "allSettled", "race"] as const) {
|
||||
test.failing(`Promise.${name} rejects invalid input with TypeError`, async () => {
|
||||
for (const name of ["all", "allSettled", "race", "any"] as const) {
|
||||
test(`Promise.${name} rejects invalid input with TypeError`, async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/all/S25.4.4.1_A3.1_T1.js
|
||||
// test/built-ins/Promise/all/S25.4.4.1_A3.1_T2.js
|
||||
// test/built-ins/Promise/allSettled/iter-arg-is-number-reject.js
|
||||
// test/built-ins/Promise/race/iter-arg-is-number-reject.js
|
||||
// test/built-ins/Promise/any/iter-arg-is-number-reject.js
|
||||
expect(
|
||||
await value(`
|
||||
try {
|
||||
@@ -599,7 +596,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
})
|
||||
}
|
||||
|
||||
test.failing("Promise.all consumes sparse positions as undefined", async () => {
|
||||
test("Promise.all consumes sparse positions as undefined", async () => {
|
||||
// Source: test/built-ins/Array/from/from-array.js (array iterator hole behavior)
|
||||
expect(
|
||||
await value(`
|
||||
@@ -611,7 +608,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual([2, true, 1])
|
||||
})
|
||||
|
||||
test.failing("Promise.allSettled consumes sparse positions as undefined", async () => {
|
||||
test("Promise.allSettled consumes sparse positions as undefined", async () => {
|
||||
// Source: test/built-ins/Array/from/from-array.js (array iterator hole behavior)
|
||||
expect(
|
||||
await value(`
|
||||
@@ -623,7 +620,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual([2, "fulfilled", true, { status: "fulfilled", value: 1 }])
|
||||
})
|
||||
|
||||
test.failing("Promise.race consumes a sparse first position as undefined", async () => {
|
||||
test("Promise.race consumes a sparse first position as undefined", async () => {
|
||||
// Source: test/built-ins/Array/from/from-array.js (array iterator hole behavior)
|
||||
expect(
|
||||
await value(`
|
||||
@@ -634,7 +631,18 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toBe(true)
|
||||
})
|
||||
|
||||
test.failing("Promise.all settles after reactions attached to its inputs", async () => {
|
||||
test("Promise.any consumes a sparse first position as an undefined fulfillment", async () => {
|
||||
// Source: test/built-ins/Array/from/from-array.js (array iterator hole behavior)
|
||||
expect(
|
||||
await value(`
|
||||
const input = []
|
||||
input[1] = Promise.reject("loses")
|
||||
return (await Promise.any(input)) === undefined
|
||||
`),
|
||||
).toBe(true)
|
||||
})
|
||||
|
||||
test("Promise.all settles after reactions attached to its inputs", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/all/S25.4.4.1_A7.2_T1.js
|
||||
// test/built-ins/Promise/all/S25.4.4.1_A8.1_T1.js
|
||||
@@ -653,7 +661,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual([1, 2, 3, 4, 5])
|
||||
})
|
||||
|
||||
test.failing("Promise.allSettled settles after reactions attached to its inputs", async () => {
|
||||
test("Promise.allSettled settles after reactions attached to its inputs", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/allSettled/resolved-sequence.js
|
||||
// test/built-ins/Promise/allSettled/resolved-sequence-extra-ticks.js
|
||||
@@ -674,7 +682,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual([1, 2, 3, 4, 5])
|
||||
})
|
||||
|
||||
test.failing("Promise.race settles in a reaction after its winning input", async () => {
|
||||
test("Promise.race settles in a reaction after its winning input", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/race/S25.4.4.3_A6.1_T1.js
|
||||
// test/built-ins/Promise/race/resolved-sequence-extra-ticks.js
|
||||
@@ -692,7 +700,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual([1, 2, 3, 4, 5])
|
||||
})
|
||||
|
||||
test.failing("then reactions route and propagate fulfillment and rejection", async () => {
|
||||
test("then reactions route and propagate fulfillment and rejection", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/prototype/then/prfm-fulfilled.js
|
||||
// test/built-ins/Promise/prototype/then/prfm-rejected.js
|
||||
@@ -726,7 +734,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
])
|
||||
})
|
||||
|
||||
test.failing("then reactions preserve breadth-first queue order", async () => {
|
||||
test("then reactions preserve breadth-first queue order", async () => {
|
||||
// Source: test/built-ins/Promise/prototype/then/S25.4.4_A1.1_T1.js
|
||||
expect(
|
||||
await value(`
|
||||
@@ -741,7 +749,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
|
||||
})
|
||||
|
||||
test.failing("then rejects direct self-resolution for fulfilled and rejected sources", async () => {
|
||||
test("then rejects direct self-resolution for fulfilled and rejected sources", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/prototype/then/resolve-settled-fulfilled-self.js
|
||||
// test/built-ins/Promise/prototype/then/resolve-settled-rejected-self.js
|
||||
@@ -761,7 +769,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual(["TypeError", "TypeError"])
|
||||
})
|
||||
|
||||
test.failing("catch delegates rejection handling and preserves fulfillment", async () => {
|
||||
test("catch delegates rejection handling and preserves fulfillment", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/prototype/catch/S25.4.5.1_A2.1_T1.js
|
||||
// test/built-ins/Promise/prototype/catch/S25.4.5.1_A3.1_T1.js
|
||||
@@ -776,7 +784,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual([1, 4])
|
||||
})
|
||||
|
||||
test.failing("finally preserves or replaces the original settlement", async () => {
|
||||
test("finally preserves or replaces the original settlement", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/prototype/finally/resolution-value-no-override.js
|
||||
// test/built-ins/Promise/prototype/finally/rejection-reason-no-fulfill.js
|
||||
@@ -799,7 +807,109 @@ describe("Test262 expected Promise conformance", () => {
|
||||
])
|
||||
})
|
||||
|
||||
test.failing("await always resumes in a later reaction and interleaves async functions", async () => {
|
||||
test("then ignores non-callable handlers", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/prototype/then/S25.4.5.3_A4.1_T1.js
|
||||
// test/built-ins/Promise/prototype/then/S25.4.5.3_A4.1_T2.js
|
||||
// test/built-ins/Promise/prototype/then/S25.4.5.3_A5.1_T1.js
|
||||
// test/built-ins/Promise/prototype/then/S25.4.5.3_A5.2_T1.js
|
||||
// (adapted: only non-callable handlers are probed; callables that are not plain
|
||||
// functions, such as tool references, intentionally throw in CodeMode)
|
||||
expect(
|
||||
await value(`
|
||||
const observe = async (promise) => {
|
||||
try { return ["fulfilled", await promise] } catch (reason) { return ["rejected", reason] }
|
||||
}
|
||||
return await Promise.all([
|
||||
observe(Promise.resolve(1).then(2)),
|
||||
observe(Promise.resolve(4).then(null, null)),
|
||||
observe(Promise.resolve(5).then({}, "x")),
|
||||
observe(Promise.reject(3).then(null, "x")),
|
||||
observe(Promise.reject(6).then(7, {})),
|
||||
])
|
||||
`),
|
||||
).toEqual([
|
||||
["fulfilled", 1],
|
||||
["fulfilled", 4],
|
||||
["fulfilled", 5],
|
||||
["rejected", 3],
|
||||
["rejected", 6],
|
||||
])
|
||||
})
|
||||
|
||||
test("finally waits for a returned promise and preserves or replaces settlement", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/prototype/finally/resolved-observable-then-calls.js
|
||||
// test/built-ins/Promise/prototype/finally/rejected-observable-then-calls.js
|
||||
// test/built-ins/Promise/prototype/finally/resolution-value-no-override.js
|
||||
expect(
|
||||
await value(`
|
||||
const observe = async (promise) => {
|
||||
try { return ["fulfilled", await promise] } catch (reason) { return ["rejected", reason] }
|
||||
}
|
||||
const order = []
|
||||
const cleanup = async () => {
|
||||
await Promise.resolve()
|
||||
order.push("cleanup")
|
||||
}
|
||||
const settled = await Promise.resolve("kept").finally(() => cleanup())
|
||||
order.push("settled:" + settled)
|
||||
return [
|
||||
await observe(Promise.resolve(1).finally(() => Promise.resolve(99))),
|
||||
order,
|
||||
await observe(Promise.resolve(2).finally(() => Promise.reject(3))),
|
||||
await observe(Promise.reject(4).finally(() => Promise.resolve(99))),
|
||||
]
|
||||
`),
|
||||
).toEqual([
|
||||
["fulfilled", 1],
|
||||
["cleanup", "settled:kept"],
|
||||
["rejected", 3],
|
||||
["rejected", 4],
|
||||
])
|
||||
})
|
||||
|
||||
test("then adopts a returned rejected promise", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/prototype/then/rxn-handler-fulfilled-return-abrupt.js
|
||||
// test/built-ins/Promise/resolve/resolve-promise.js
|
||||
// (adapted: the fulfillment handler returns an already-rejected promise instead of
|
||||
// throwing, and the rejection handler recovers with a fulfilled promise)
|
||||
expect(
|
||||
await value(`
|
||||
const observe = async (promise) => {
|
||||
try { return ["fulfilled", await promise] } catch (reason) { return ["rejected", reason] }
|
||||
}
|
||||
return await Promise.all([
|
||||
observe(Promise.resolve(1).then(() => Promise.reject("bad"))),
|
||||
observe(Promise.reject(2).then(undefined, () => Promise.resolve("ok"))),
|
||||
])
|
||||
`),
|
||||
).toEqual([
|
||||
["rejected", "bad"],
|
||||
["fulfilled", "ok"],
|
||||
])
|
||||
})
|
||||
|
||||
test("independent reactions on one source each observe the same settlement", async () => {
|
||||
// Source: test/built-ins/Promise/prototype/then/S25.4.4_A2.1_T1.js
|
||||
// (adapted: the multiple-reactions family is asserted through the values every
|
||||
// reaction returns instead of a shared completion counter)
|
||||
expect(
|
||||
await value(`
|
||||
const fulfilled = Promise.resolve(7)
|
||||
const rejected = Promise.reject(8)
|
||||
return await Promise.all([
|
||||
fulfilled.then((value) => "first:" + value),
|
||||
fulfilled.then((value) => "second:" + value),
|
||||
rejected.catch((reason) => "first:" + reason),
|
||||
rejected.catch((reason) => "second:" + reason),
|
||||
])
|
||||
`),
|
||||
).toEqual(["first:7", "second:7", "first:8", "second:8"])
|
||||
})
|
||||
|
||||
test("await always resumes in a later reaction and interleaves async functions", async () => {
|
||||
// Sources:
|
||||
// test/language/expressions/await/async-await-interleaved.js
|
||||
// test/language/expressions/await/await-non-promise.js
|
||||
@@ -814,7 +924,7 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toEqual(["first:1", "second:1", "first:2", "second:2"])
|
||||
})
|
||||
|
||||
test.failing("an async function rejects when it resolves with its own promise", async () => {
|
||||
test("an async function rejects when it resolves with its own promise", async () => {
|
||||
// Adapted from the self-resolution requirement represented by:
|
||||
// test/built-ins/Promise/resolve-self.js
|
||||
// test/built-ins/Promise/resolve/S25.4.4.5_A4.1_T1.js
|
||||
@@ -904,3 +1014,410 @@ describe("Test262 expected Promise conformance", () => {
|
||||
).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
describe("Test262 Promise.any", () => {
|
||||
test("is a callable static that returns a promise", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/any/is-function.js
|
||||
// test/built-ins/Promise/any/returns-promise.js
|
||||
expect(
|
||||
await value(`
|
||||
const promise = Promise.any([1])
|
||||
return [typeof Promise.any, promise instanceof Promise, await promise]
|
||||
`),
|
||||
).toEqual(["function", true, 1])
|
||||
})
|
||||
|
||||
test("fulfills with the first fulfilled member, ignoring rejections", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/any/resolved-sequence-mixed.js
|
||||
// test/built-ins/Promise/any/resolved-sequence-with-rejections.js
|
||||
// test/built-ins/Promise/any/reject-ignored-immed.js
|
||||
expect(
|
||||
await value(`
|
||||
return [
|
||||
await Promise.any([Promise.reject("a"), Promise.resolve(1), Promise.resolve(2)]),
|
||||
await Promise.any([Promise.reject("a"), "plain", Promise.reject("b")]),
|
||||
]
|
||||
`),
|
||||
).toEqual([1, "plain"])
|
||||
})
|
||||
|
||||
test("a fulfillment wins over a later rejection of another member", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/any/resolve-ignores-late-rejection.js
|
||||
// test/built-ins/Promise/any/resolve-ignores-late-rejection-deferred.js
|
||||
expect(
|
||||
await value(`
|
||||
let rejectLate
|
||||
const late = new Promise((_, reject) => { rejectLate = reject })
|
||||
const result = await Promise.any([late, Promise.resolve("won")])
|
||||
rejectLate("too late")
|
||||
return result
|
||||
`),
|
||||
).toBe("won")
|
||||
})
|
||||
|
||||
test("rejects with an AggregateError carrying the reasons in input order", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/any/reject-all-mixed.js
|
||||
// test/built-ins/Promise/any/reject-immed.js
|
||||
// test/built-ins/Promise/any/reject-deferred.js
|
||||
expect(
|
||||
await value(`
|
||||
let rejectLate
|
||||
const late = new Promise((_, reject) => { rejectLate = reject })
|
||||
const aggregate = Promise.any([Promise.reject("first"), late, Promise.reject("third")])
|
||||
rejectLate("second")
|
||||
try {
|
||||
await aggregate
|
||||
return "fulfilled"
|
||||
} catch (error) {
|
||||
return {
|
||||
isAggregate: error instanceof AggregateError,
|
||||
isError: error instanceof Error,
|
||||
name: error.name,
|
||||
message: error.message,
|
||||
errors: error.errors,
|
||||
}
|
||||
}
|
||||
`),
|
||||
).toEqual({
|
||||
isAggregate: true,
|
||||
isError: true,
|
||||
name: "AggregateError",
|
||||
message: "All promises were rejected",
|
||||
errors: ["first", "second", "third"],
|
||||
})
|
||||
})
|
||||
|
||||
test("rejects an empty input with an empty AggregateError", async () => {
|
||||
// Source: test/built-ins/Promise/any/iter-arg-is-empty-iterable-reject.js
|
||||
expect(
|
||||
await value(`
|
||||
try {
|
||||
await Promise.any([])
|
||||
return "fulfilled"
|
||||
} catch (error) {
|
||||
return [error instanceof AggregateError, error.errors.length]
|
||||
}
|
||||
`),
|
||||
).toEqual([true, 0])
|
||||
})
|
||||
|
||||
test("consumes a string input as its characters", async () => {
|
||||
// Source: test/built-ins/Promise/any/iter-arg-is-string-resolve.js
|
||||
expect(await value(`return await Promise.any("abc")`)).toBe("a")
|
||||
})
|
||||
|
||||
test("rejects an empty string input with an empty AggregateError", async () => {
|
||||
// Source: test/built-ins/Promise/any/iter-arg-is-empty-string-reject.js
|
||||
expect(
|
||||
await value(`
|
||||
try {
|
||||
await Promise.any("")
|
||||
return "fulfilled"
|
||||
} catch (error) {
|
||||
return [error instanceof AggregateError, error.errors.length]
|
||||
}
|
||||
`),
|
||||
).toEqual([true, 0])
|
||||
})
|
||||
|
||||
test("fulfills with the first member that does not reject", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/any/resolve-from-reject-catch.js
|
||||
// test/built-ins/Promise/any/resolve-from-resolve-reject-catch.js
|
||||
expect(
|
||||
await value(`
|
||||
return await Promise.any([
|
||||
Promise.reject("a"),
|
||||
new Promise((resolve, reject) => reject("b")),
|
||||
Promise.all([Promise.reject("c")]),
|
||||
Promise.resolve(Promise.reject("d").catch((reason) => reason)),
|
||||
])
|
||||
`),
|
||||
).toBe("d")
|
||||
})
|
||||
|
||||
test("settles after reactions attached to its inputs", async () => {
|
||||
// Source: test/built-ins/Promise/any/resolved-sequence.js
|
||||
expect(
|
||||
await value(`
|
||||
const sequence = [1]
|
||||
const input = Promise.resolve(1)
|
||||
const aggregate = Promise.any([input])
|
||||
aggregate.then(() => sequence.push(4))
|
||||
input.then(() => sequence.push(3)).then(() => sequence.push(5))
|
||||
sequence.push(2)
|
||||
await aggregate
|
||||
await Promise.resolve()
|
||||
return sequence
|
||||
`),
|
||||
).toEqual([1, 2, 3, 4, 5])
|
||||
})
|
||||
})
|
||||
|
||||
describe("Test262 AggregateError", () => {
|
||||
test("constructs from an errors collection and an optional message", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/AggregateError/errors-iterabletolist.js
|
||||
// test/built-ins/AggregateError/message-undefined-no-prop.js
|
||||
expect(
|
||||
await value(`
|
||||
const input = ["x", "y"]
|
||||
const withMessage = new AggregateError(input, "msg")
|
||||
const bare = new AggregateError([])
|
||||
return [
|
||||
withMessage.name,
|
||||
withMessage.message,
|
||||
withMessage.errors,
|
||||
withMessage.errors !== input,
|
||||
withMessage instanceof AggregateError,
|
||||
withMessage instanceof Error,
|
||||
bare.message,
|
||||
bare.errors,
|
||||
]
|
||||
`),
|
||||
).toEqual(["AggregateError", "msg", ["x", "y"], true, true, true, "", []])
|
||||
})
|
||||
|
||||
test("rejects a non-collection errors argument with TypeError", async () => {
|
||||
// Source: test/built-ins/AggregateError/errors-iterabletolist-failures.js
|
||||
expect(
|
||||
await value(`
|
||||
try {
|
||||
new AggregateError(42)
|
||||
return "constructed"
|
||||
} catch (error) {
|
||||
return error.name
|
||||
}
|
||||
`),
|
||||
).toBe("TypeError")
|
||||
})
|
||||
|
||||
test("is callable without new", async () => {
|
||||
// Source: test/built-ins/AggregateError/newtarget-is-undefined.js
|
||||
expect(
|
||||
await value(`
|
||||
const error = AggregateError(["x"], "m")
|
||||
return [error instanceof AggregateError, error instanceof Error, error.name, error.message, error.errors]
|
||||
`),
|
||||
).toEqual([true, true, "AggregateError", "m", ["x"]])
|
||||
})
|
||||
|
||||
test("coerces a non-string message to a string", async () => {
|
||||
// Source: test/built-ins/AggregateError/message-method-prop-cast.js (value coercion only; the
|
||||
// upstream object-with-toString case is omitted because the sandbox has no user toString dispatch)
|
||||
expect(
|
||||
await value(`
|
||||
return [
|
||||
new AggregateError([], 42).message,
|
||||
new AggregateError([], false).message,
|
||||
new AggregateError([], true).message,
|
||||
new AggregateError([], null).message,
|
||||
]
|
||||
`),
|
||||
).toEqual(["42", "false", "true", "null"])
|
||||
})
|
||||
})
|
||||
|
||||
describe("Test262 Promise constructor", () => {
|
||||
test("constructs a promise, handing the executor callable resolve/reject", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/constructor.js
|
||||
// test/built-ins/Promise/exec-args.js
|
||||
expect(
|
||||
await value(`
|
||||
let observed
|
||||
const promise = new Promise((resolve, reject) => {
|
||||
observed = [typeof resolve, typeof reject]
|
||||
resolve("done")
|
||||
})
|
||||
return [promise instanceof Promise, observed, await promise]
|
||||
`),
|
||||
).toEqual([true, ["function", "function"], "done"])
|
||||
})
|
||||
|
||||
test("a missing or non-callable executor is a TypeError", async () => {
|
||||
// Source: test/built-ins/Promise/executor-not-callable.js
|
||||
expect(
|
||||
await value(`
|
||||
const outcomes = []
|
||||
for (const make of [() => new Promise(), () => new Promise(1), () => new Promise({})]) {
|
||||
try {
|
||||
make()
|
||||
outcomes.push("constructed")
|
||||
} catch (error) {
|
||||
outcomes.push(error.name)
|
||||
}
|
||||
}
|
||||
return outcomes
|
||||
`),
|
||||
).toEqual(["TypeError", "TypeError", "TypeError"])
|
||||
})
|
||||
|
||||
test("resolves immediately or later through an escaping resolver", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/resolve-non-thenable-immed.js
|
||||
// test/built-ins/Promise/resolve-non-thenable-deferred.js
|
||||
// test/built-ins/Promise/create-resolving-functions-resolve.js
|
||||
expect(
|
||||
await value(`
|
||||
let settle
|
||||
const deferred = new Promise((resolve) => { settle = resolve })
|
||||
const immediate = new Promise((resolve) => resolve("now"))
|
||||
settle("later")
|
||||
return [await immediate, await deferred]
|
||||
`),
|
||||
).toEqual(["now", "later"])
|
||||
})
|
||||
|
||||
test("rejects through reject and through an abrupt executor completion", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/reject-via-fn-immed.js
|
||||
// test/built-ins/Promise/reject-via-abrupt.js
|
||||
expect(
|
||||
await value(`
|
||||
const observe = async (promise) => {
|
||||
try { return ["fulfilled", await promise] } catch (reason) { return ["rejected", reason.message ?? reason] }
|
||||
}
|
||||
return [
|
||||
await observe(new Promise((_, reject) => reject("nope"))),
|
||||
await observe(new Promise(() => { throw new Error("boom") })),
|
||||
]
|
||||
`),
|
||||
).toEqual([
|
||||
["rejected", "nope"],
|
||||
["rejected", "boom"],
|
||||
])
|
||||
})
|
||||
|
||||
test("only the first settlement counts", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/reject-ignored-via-fn-immed.js
|
||||
// test/built-ins/Promise/resolve-ignored-via-fn-immed.js
|
||||
expect(
|
||||
await value(`
|
||||
return [
|
||||
await new Promise((resolve, reject) => { resolve("first"); reject("second"); resolve("third") }),
|
||||
await new Promise((resolve) => { resolve(resolve("inner") === undefined ? "unreached" : "also unreached") }),
|
||||
]
|
||||
`),
|
||||
).toEqual(["first", "inner"])
|
||||
})
|
||||
|
||||
test("escaped resolvers keep first-settle-wins in both directions", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/reject-ignored-via-fn-deferred.js
|
||||
// test/built-ins/Promise/resolve-ignored-via-fn-deferred.js
|
||||
expect(
|
||||
await value(`
|
||||
let resolveRejected, rejectRejected
|
||||
const rejected = new Promise((resolve, reject) => { resolveRejected = resolve; rejectRejected = reject })
|
||||
rejectRejected("first")
|
||||
const lateResolve = resolveRejected("late")
|
||||
let resolveFulfilled, rejectFulfilled
|
||||
const fulfilled = new Promise((resolve, reject) => { resolveFulfilled = resolve; rejectFulfilled = reject })
|
||||
resolveFulfilled()
|
||||
const lateReject = rejectFulfilled(new Promise(() => {}))
|
||||
try {
|
||||
await rejected
|
||||
return "fulfilled"
|
||||
} catch (reason) {
|
||||
return [reason, lateResolve === undefined, (await fulfilled) === undefined, lateReject === undefined]
|
||||
}
|
||||
`),
|
||||
).toEqual(["first", true, true, true])
|
||||
})
|
||||
|
||||
test("a queued reaction chain observes a later rejection through a handler-less then", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/reject-via-fn-immed-queue.js
|
||||
// test/built-ins/Promise/reject-via-fn-deferred-queue.js
|
||||
// test/built-ins/Promise/reject-via-abrupt-queue.js
|
||||
expect(
|
||||
await value(`
|
||||
const observe = (promise) => promise.then(() => "wrong").then(() => "also wrong", (reason) => "caught:" + reason)
|
||||
let reject
|
||||
const deferred = new Promise((_, r) => { reject = r })
|
||||
const chained = observe(deferred)
|
||||
reject("boom")
|
||||
return [
|
||||
await observe(new Promise((_, r) => r("immed"))),
|
||||
await chained,
|
||||
await observe(new Promise(() => { throw "abrupt" })),
|
||||
]
|
||||
`),
|
||||
).toEqual(["caught:immed", "caught:boom", "caught:abrupt"])
|
||||
})
|
||||
|
||||
test("an exception after resolve is ignored", async () => {
|
||||
// Source: test/built-ins/Promise/exception-after-resolve-in-executor.js
|
||||
expect(await value(`return await new Promise((resolve) => { resolve("kept"); throw new Error("dropped") })`)).toBe(
|
||||
"kept",
|
||||
)
|
||||
})
|
||||
|
||||
test("resolving with a promise adopts its settlement", async () => {
|
||||
// Sources:
|
||||
// test/built-ins/Promise/resolve-thenable-immed.js (promise-adoption portion)
|
||||
// test/built-ins/Promise/all/S25.4.4.1_A2.3_T1.js (resolution adoption semantics)
|
||||
expect(
|
||||
await value(`
|
||||
const adoptedValue = await new Promise((resolve) => resolve(Promise.resolve("adopted")))
|
||||
try {
|
||||
await new Promise((resolve) => resolve(Promise.reject("bad")))
|
||||
return [adoptedValue, "fulfilled"]
|
||||
} catch (reason) {
|
||||
return [adoptedValue, reason]
|
||||
}
|
||||
`),
|
||||
).toEqual(["adopted", "bad"])
|
||||
})
|
||||
|
||||
test("resolving with the promise itself rejects with TypeError", async () => {
|
||||
// Source: test/built-ins/Promise/resolve-self.js
|
||||
expect(
|
||||
await value(`
|
||||
let settle
|
||||
const promise = new Promise((resolve) => { settle = resolve })
|
||||
settle(promise)
|
||||
try {
|
||||
await promise
|
||||
return "fulfilled"
|
||||
} catch (error) {
|
||||
return error.name
|
||||
}
|
||||
`),
|
||||
).toBe("TypeError")
|
||||
})
|
||||
|
||||
test("executor runs synchronously before the constructor returns", async () => {
|
||||
// Source: test/built-ins/Promise/executor-call-context-strict.js (synchronous Call(executor) step)
|
||||
expect(
|
||||
await value(`
|
||||
const sequence = []
|
||||
sequence.push("before")
|
||||
new Promise((resolve) => { sequence.push("executor"); resolve() })
|
||||
sequence.push("after")
|
||||
return sequence
|
||||
`),
|
||||
).toEqual(["before", "executor", "after"])
|
||||
})
|
||||
|
||||
test.failing("calling Promise without new throws TypeError", async () => {
|
||||
// Source: test/built-ins/Promise/undefined-newtarget.js
|
||||
// The sandbox currently reports a generic Error ("Only tools are callable in CodeMode.").
|
||||
expect(
|
||||
await value(`
|
||||
try {
|
||||
Promise(() => {})
|
||||
return "called"
|
||||
} catch (error) {
|
||||
return error.name
|
||||
}
|
||||
`),
|
||||
).toBe("TypeError")
|
||||
})
|
||||
})
|
||||
|
||||
@@ -3,8 +3,9 @@ import { Effect, Schema } from "effect"
|
||||
import { CodeMode, Tool, toolError } from "../src/index.js"
|
||||
|
||||
// Wave 5 acceptance suite: first-class promise values. Un-awaited tool calls start eagerly on
|
||||
// supervised fibers, `await` settles them, and Promise.all/allSettled/race/resolve/reject are
|
||||
// ordinary functions over arbitrary arrays mixing promises and plain values.
|
||||
// supervised fibers, `await` settles them, Promise.all/allSettled/race/resolve/reject are
|
||||
// ordinary functions over arbitrary arrays mixing promises and plain values, and
|
||||
// .then/.catch/.finally chain reactions onto any promise.
|
||||
|
||||
type Trace = {
|
||||
starts: Array<number>
|
||||
@@ -184,7 +185,7 @@ describe("first-class promise values", () => {
|
||||
expect(result.toolCalls).toStrictEqual([{ name: "host.sleepy" }])
|
||||
})
|
||||
|
||||
test("await of a non-promise value is a passthrough no-op", async () => {
|
||||
test("await of a non-promise value passes it through unchanged", async () => {
|
||||
expect(await value(`return await 42`)).toBe(42)
|
||||
expect(await value(`const x = await "s"; return x`)).toBe("s")
|
||||
expect(await value(`return await null`)).toBeNull()
|
||||
@@ -935,16 +936,124 @@ describe("timeout interruption of forked calls", () => {
|
||||
})
|
||||
})
|
||||
|
||||
describe("unsupported promise surface", () => {
|
||||
test(".then/.catch/.finally give a clear await-instead error", async () => {
|
||||
for (const method of ["then", "catch", "finally"]) {
|
||||
const diagnostic = await error(`return tools.host.sleepy({ id: 1 }).${method}((x) => x)`)
|
||||
expect(diagnostic.kind).toBe("UnsupportedSyntax")
|
||||
expect(diagnostic.message).toContain(`Promise.prototype.${method} is not supported`)
|
||||
expect(diagnostic.message).toContain("await")
|
||||
}
|
||||
describe("promise chaining", () => {
|
||||
test("then transforms tool results and adopts returned promises across a chain", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
return await tools.host
|
||||
.sleepy({ id: 2 })
|
||||
.then((id) => tools.host.sleepy({ id: id + 1 }))
|
||||
.then((id) => id * 10)
|
||||
`),
|
||||
).toBe(30)
|
||||
})
|
||||
|
||||
test("handlers are deferred and run in attach order", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
const order = []
|
||||
const promise = Promise.resolve(1)
|
||||
promise.then(() => order.push("h1"))
|
||||
promise.then(() => order.push("h2"))
|
||||
order.push("sync")
|
||||
await promise
|
||||
return order
|
||||
`),
|
||||
).toEqual(["sync", "h1", "h2"])
|
||||
})
|
||||
|
||||
test("catch recovers a tool failure and preserves fulfillment", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
return [
|
||||
await tools.host.fail({}).catch((error) => error.message),
|
||||
await tools.host.sleepy({ id: 4 }).catch(() => "unused"),
|
||||
]
|
||||
`),
|
||||
).toEqual(["Lookup refused", 4])
|
||||
})
|
||||
|
||||
test("finally observes settlement without changing the value", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
const events = []
|
||||
const result = await tools.host.sleepy({ id: 5 }).finally(() => events.push("cleanup"))
|
||||
return [result, events]
|
||||
`),
|
||||
).toEqual([5, ["cleanup"]])
|
||||
})
|
||||
|
||||
test("a settled, un-awaited rejected chain tail warns exactly once", async () => {
|
||||
const result = await run(`
|
||||
Promise.reject(new Error("boom")).then((value) => value)
|
||||
await Promise.resolve()
|
||||
return "done"
|
||||
`)
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.value).toBe("done")
|
||||
// The source rejection belongs to the chain (no warning); only the derived tail warns.
|
||||
expect(result.warnings).toStrictEqual([
|
||||
{ kind: "ExecutionFailure", message: "Unhandled rejection from an un-awaited promise: Uncaught: boom" },
|
||||
])
|
||||
})
|
||||
|
||||
test("a catch handler silences the chain's rejection warning", async () => {
|
||||
const result = await run(`
|
||||
Promise.reject(new Error("boom")).catch(() => "handled")
|
||||
await Promise.resolve()
|
||||
return "done"
|
||||
`)
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.warnings).toBeUndefined()
|
||||
})
|
||||
|
||||
test("non-plain-function handlers fail loudly instead of being ignored", async () => {
|
||||
const diagnostic = await error(`return await tools.host.sleepy({ id: 1 }).then(tools.host.completed)`)
|
||||
expect(diagnostic.message).toContain("Promise.prototype.then handlers must be plain functions")
|
||||
})
|
||||
|
||||
test("chaining methods are opaque references until called", async () => {
|
||||
expect(await value(`return typeof tools.host.sleepy({ id: 1 }).then`)).toBe("function")
|
||||
})
|
||||
})
|
||||
|
||||
describe("combinator settlement timing", () => {
|
||||
test("a combinator settling one reaction turn after the program returns is interrupted silently", async () => {
|
||||
// The aggregate's one-turn settlement delay (V8 parity) means an immediately-returning
|
||||
// program abandons it while still pending: interrupted like any pending work, so no
|
||||
// rejection warning survives - the member itself was observed by the combinator.
|
||||
const result = await run(`
|
||||
Promise.all([Promise.reject(new Error("boom"))])
|
||||
return "done"
|
||||
`)
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.value).toBe("done")
|
||||
expect(result.warnings).toBeUndefined()
|
||||
})
|
||||
|
||||
test("a combinator settles one reaction turn after its members, as in V8", async () => {
|
||||
// Regression for the race winner flip: Promise.all's settlement burns a reaction turn,
|
||||
// so a plain resolved value entered in the same race wins, and a fail-fast aggregate
|
||||
// cannot beat it into rejection.
|
||||
expect(
|
||||
await value(`
|
||||
const pending = tools.host.sleepy({ id: 9, ms: 60000 })
|
||||
const winner = await Promise.race([Promise.all([Promise.resolve(1)]), Promise.resolve(2)])
|
||||
try {
|
||||
const raced = await Promise.race([Promise.all([Promise.reject("x"), pending]), Promise.resolve("ok")])
|
||||
return [winner, "fulfilled", raced]
|
||||
} catch (reason) {
|
||||
return [winner, "rejected", reason]
|
||||
}
|
||||
`),
|
||||
).toEqual([2, "fulfilled", "ok"])
|
||||
})
|
||||
})
|
||||
|
||||
describe("unsupported promise surface", () => {
|
||||
test("other property reads on a promise hint at the missing await", async () => {
|
||||
const diagnostic = await error(`return tools.host.sleepy({ id: 1 }).value`)
|
||||
expect(diagnostic.kind).toBe("InvalidDataValue")
|
||||
@@ -953,15 +1062,179 @@ describe("unsupported promise surface", () => {
|
||||
})
|
||||
|
||||
test("unknown Promise statics list what is available", async () => {
|
||||
const diagnostic = await error(`return await Promise.any([tools.host.sleepy({ id: 1 })])`)
|
||||
expect(diagnostic.message).toContain("Promise.any is not available")
|
||||
expect(diagnostic.message).toContain("Promise.allSettled")
|
||||
})
|
||||
|
||||
test("new Promise(...) points at tool calls instead", async () => {
|
||||
const diagnostic = await error(`return new Promise((resolve) => resolve(1))`)
|
||||
expect(diagnostic.kind).toBe("UnsupportedSyntax")
|
||||
expect(diagnostic.message).toContain("new Promise(...) is not supported")
|
||||
expect(diagnostic.message).toContain("already return promises")
|
||||
const diagnostic = await error(`return await Promise.withResolvers()`)
|
||||
expect(diagnostic.message).toContain("Promise.withResolvers is not available")
|
||||
expect(diagnostic.message).toContain("Promise.any")
|
||||
})
|
||||
})
|
||||
|
||||
describe("Promise.any", () => {
|
||||
test("first tool success wins; failing and losing calls are handled silently", async () => {
|
||||
const trace = makeTrace()
|
||||
const result = await run(
|
||||
`
|
||||
const winner = await Promise.any([
|
||||
tools.host.fail({}),
|
||||
tools.host.sleepy({ id: 1, ms: 5 }),
|
||||
tools.host.sleepy({ id: 2, ms: 60000 }),
|
||||
])
|
||||
return winner
|
||||
`,
|
||||
{ trace },
|
||||
)
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.value).toBe(1)
|
||||
// The slow loser stays execution-owned and is interrupted at completion; the tool
|
||||
// failure was observed by the aggregate, so no rejection warning survives.
|
||||
expect(result.warnings).toBeUndefined()
|
||||
expect(trace.interrupted).toBe(1)
|
||||
})
|
||||
|
||||
test("all members failing rejects with catch-normalized reasons in input order", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
try {
|
||||
await Promise.any([tools.host.fail({}), Promise.reject("plain")])
|
||||
return "fulfilled"
|
||||
} catch (error) {
|
||||
return [error.name, error.errors.map((reason) => reason.message ?? reason)]
|
||||
}
|
||||
`),
|
||||
).toEqual(["AggregateError", ["Lookup refused", "plain"]])
|
||||
})
|
||||
|
||||
test("settles one reaction turn after its deciding member, as in V8", async () => {
|
||||
expect(await value(`return await Promise.race([Promise.any([Promise.resolve(1)]), Promise.resolve(2)])`)).toBe(2)
|
||||
})
|
||||
|
||||
test("a tie is decided by settlement order, not input order", async () => {
|
||||
// Handlers run in attach order, so `first` settles before `second` and wins
|
||||
// despite its later input position - as in real JS.
|
||||
expect(
|
||||
await value(`
|
||||
const first = Promise.resolve().then(() => "one")
|
||||
const second = Promise.resolve().then(() => "two")
|
||||
return await Promise.any([second, first])
|
||||
`),
|
||||
).toBe("one")
|
||||
})
|
||||
|
||||
test("an abandoned rejecting aggregate is interrupted silently at the return", async () => {
|
||||
const result = await run(`
|
||||
Promise.any([Promise.reject(new Error("boom"))])
|
||||
return "done"
|
||||
`)
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.value).toBe("done")
|
||||
expect(result.warnings).toBeUndefined()
|
||||
})
|
||||
})
|
||||
|
||||
describe("promise construction", () => {
|
||||
test("a deferred gate coordinates tool results across async functions", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
let openGate
|
||||
const gate = new Promise((resolve) => { openGate = resolve })
|
||||
const worker = (async () => {
|
||||
const id = await gate
|
||||
return id * 2
|
||||
})()
|
||||
openGate(await tools.host.sleepy({ id: 21, ms: 5 }))
|
||||
return await worker
|
||||
`),
|
||||
).toBe(42)
|
||||
})
|
||||
|
||||
test("the .then(resolve) bridge settles a constructed promise", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
const bridged = new Promise((resolve, reject) => {
|
||||
tools.host.sleepy({ id: 7, ms: 5 }).then(resolve, reject)
|
||||
})
|
||||
return await bridged
|
||||
`),
|
||||
).toBe(7)
|
||||
})
|
||||
|
||||
test("constructed promises participate in combinators", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
let settle
|
||||
const manual = new Promise((resolve) => { settle = resolve })
|
||||
const race = Promise.race([manual, tools.host.sleepy({ id: 3, ms: 60000 })])
|
||||
const all = Promise.all([manual, "plain"])
|
||||
const any = Promise.any([manual, new Promise(() => {})])
|
||||
settle("manual")
|
||||
return [await race, await all, await any]
|
||||
`),
|
||||
).toEqual(["manual", ["manual", "plain"], "manual"])
|
||||
})
|
||||
|
||||
test("resolving with a pending promise adopts its later settlement", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
let innerResolve, innerReject
|
||||
const adopted = new Promise((resolve) => resolve(new Promise((resolve) => { innerResolve = resolve })))
|
||||
const adoptedRejection = new Promise((resolve) => resolve(new Promise((_, reject) => { innerReject = reject })))
|
||||
innerResolve("later")
|
||||
innerReject("bad")
|
||||
try {
|
||||
return [await adopted, await adoptedRejection]
|
||||
} catch (reason) {
|
||||
return [await adopted, reason]
|
||||
}
|
||||
`),
|
||||
).toEqual(["later", "bad"])
|
||||
})
|
||||
|
||||
test("an async executor's post-await resolve settles the promise", async () => {
|
||||
expect(
|
||||
await value(`
|
||||
const result = new Promise(async (resolve) => {
|
||||
const id = await tools.host.sleepy({ id: 5, ms: 5 })
|
||||
resolve(id * 2)
|
||||
})
|
||||
return await result
|
||||
`),
|
||||
).toBe(10)
|
||||
})
|
||||
|
||||
test("a never-settled promise is abandoned silently at the return", async () => {
|
||||
const result = await run(`
|
||||
const forever = new Promise(() => {})
|
||||
forever.then(() => {})
|
||||
return "done"
|
||||
`)
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.value).toBe("done")
|
||||
expect(result.warnings).toBeUndefined()
|
||||
})
|
||||
|
||||
test("an un-awaited constructed rejection is reported like any unhandled rejection", async () => {
|
||||
const result = await run(`
|
||||
new Promise((_, reject) => reject(new Error("dropped")))
|
||||
await Promise.resolve()
|
||||
await Promise.resolve()
|
||||
return "done"
|
||||
`)
|
||||
expect(result.ok).toBe(true)
|
||||
if (!result.ok) return
|
||||
expect(result.value).toBe("done")
|
||||
expect(result.warnings).toHaveLength(1)
|
||||
expect(result.warnings?.[0].message).toContain("Unhandled rejection")
|
||||
expect(result.warnings?.[0].message).toContain("dropped")
|
||||
})
|
||||
|
||||
test("resolver functions cannot cross the data boundary", async () => {
|
||||
const diagnostic = await error(`
|
||||
let escaped
|
||||
new Promise((resolve) => { escaped = resolve })
|
||||
return { escaped }
|
||||
`)
|
||||
expect(diagnostic.kind).toBe("InvalidDataValue")
|
||||
})
|
||||
})
|
||||
|
||||
@@ -189,16 +189,14 @@ const layer = Layer.effect(
|
||||
if (!dotgit) return undefined
|
||||
|
||||
const cwd = path.dirname(dotgit)
|
||||
const git = run(cwd, proc)
|
||||
const topLevel = yield* git(["rev-parse", "--show-toplevel"])
|
||||
const gitDir = yield* git(["rev-parse", "--git-dir"])
|
||||
const commonDir = yield* git(["rev-parse", "--git-common-dir"])
|
||||
if (gitDir.exitCode !== 0 || commonDir.exitCode !== 0) return undefined
|
||||
const result = yield* run(cwd, proc)(["rev-parse", "--git-dir", "--git-common-dir", "--show-toplevel"])
|
||||
const [gitDir, commonDir, topLevel] = result.text.split(/\r?\n/)
|
||||
if (!gitDir || !commonDir) return undefined
|
||||
|
||||
return new Repository({
|
||||
worktree: AbsolutePath.make(topLevel.exitCode === 0 ? resolvePath(cwd, topLevel.text) : cwd),
|
||||
gitDirectory: AbsolutePath.make(resolvePath(cwd, gitDir.text)),
|
||||
commonDirectory: AbsolutePath.make(resolvePath(cwd, commonDir.text)),
|
||||
worktree: AbsolutePath.make(topLevel ? resolvePath(cwd, topLevel) : cwd),
|
||||
gitDirectory: AbsolutePath.make(resolvePath(cwd, gitDir)),
|
||||
commonDirectory: AbsolutePath.make(resolvePath(cwd, commonDir)),
|
||||
})
|
||||
})
|
||||
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
export * as CopilotModels from "./models"
|
||||
|
||||
import { Money } from "@opencode-ai/schema/money"
|
||||
import { Option, Schema } from "effect"
|
||||
import { ModelV2 } from "../model"
|
||||
import { ProviderV2 } from "../provider"
|
||||
|
||||
const RemoteModel = Schema.Struct({
|
||||
model_picker_enabled: Schema.Boolean,
|
||||
id: Schema.String,
|
||||
name: Schema.String,
|
||||
version: Schema.String,
|
||||
supported_endpoints: Schema.optional(Schema.Array(Schema.String)),
|
||||
policy: Schema.optional(Schema.Struct({ state: Schema.optional(Schema.String) })),
|
||||
billing: Schema.optional(
|
||||
Schema.Struct({
|
||||
token_prices: Schema.optional(
|
||||
Schema.Struct({
|
||||
batch_size: Schema.Number,
|
||||
default: Schema.Struct({
|
||||
cache_price: Schema.Number,
|
||||
input_price: Schema.Number,
|
||||
output_price: Schema.Number,
|
||||
}),
|
||||
}),
|
||||
),
|
||||
}),
|
||||
),
|
||||
capabilities: Schema.Struct({
|
||||
family: Schema.String,
|
||||
limits: Schema.optional(
|
||||
Schema.Struct({
|
||||
max_context_window_tokens: Schema.optional(Schema.Number),
|
||||
max_output_tokens: Schema.optional(Schema.Number),
|
||||
max_prompt_tokens: Schema.optional(Schema.Number),
|
||||
vision: Schema.optional(
|
||||
Schema.Struct({
|
||||
max_prompt_image_size: Schema.Number,
|
||||
max_prompt_images: Schema.Number,
|
||||
supported_media_types: Schema.Array(Schema.String),
|
||||
}),
|
||||
),
|
||||
}),
|
||||
),
|
||||
supports: Schema.Struct({
|
||||
adaptive_thinking: Schema.optional(Schema.Boolean),
|
||||
max_thinking_budget: Schema.optional(Schema.Number),
|
||||
min_thinking_budget: Schema.optional(Schema.Number),
|
||||
reasoning_effort: Schema.optional(Schema.Array(Schema.String)),
|
||||
streaming: Schema.optional(Schema.Boolean),
|
||||
structured_outputs: Schema.optional(Schema.Boolean),
|
||||
tool_calls: Schema.optional(Schema.Boolean),
|
||||
vision: Schema.optional(Schema.Boolean),
|
||||
}),
|
||||
}),
|
||||
})
|
||||
|
||||
const Response = Schema.Struct({ data: Schema.Array(Schema.Unknown) })
|
||||
const decodeResponse = Schema.decodeUnknownSync(Response)
|
||||
const decodeModel = Schema.decodeUnknownOption(RemoteModel)
|
||||
|
||||
type RemoteModel = typeof RemoteModel.Type
|
||||
type UsableModel = RemoteModel & {
|
||||
capabilities: RemoteModel["capabilities"] & {
|
||||
limits: NonNullable<RemoteModel["capabilities"]["limits"]> & {
|
||||
max_output_tokens: number
|
||||
max_prompt_tokens: number
|
||||
}
|
||||
supports: RemoteModel["capabilities"]["supports"] & { tool_calls: boolean }
|
||||
}
|
||||
}
|
||||
|
||||
export async function get(baseURL: string, headers: RequestInit["headers"], existing: readonly ModelV2.Info[]) {
|
||||
const response = await fetch(`${baseURL}/models`, {
|
||||
headers,
|
||||
signal: AbortSignal.timeout(5_000),
|
||||
})
|
||||
if (!response.ok) throw new Error(`Failed to fetch Copilot models: ${response.status}`)
|
||||
|
||||
const remote = new Map(
|
||||
decodeResponse(await response.json()).data.flatMap((raw) => {
|
||||
const model = Option.getOrUndefined(decodeModel(raw))
|
||||
return model && usable(model) ? ([[model.id, model]] as const) : []
|
||||
}),
|
||||
)
|
||||
const result = new Map(existing.map((model) => [model.id, model]))
|
||||
|
||||
// Keep aliases and local metadata, but only when their advertised API model
|
||||
// still exists. A partial or malformed item cannot create a broken model.
|
||||
for (const [id, model] of result) {
|
||||
const current = remote.get(model.modelID)
|
||||
if (!current) {
|
||||
result.delete(id)
|
||||
continue
|
||||
}
|
||||
result.set(id, build(id, current, baseURL, model))
|
||||
}
|
||||
|
||||
for (const [id, model] of remote) {
|
||||
const key = ModelV2.ID.make(id)
|
||||
if (result.has(key)) continue
|
||||
result.set(key, build(key, model, baseURL))
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
function usable(model: RemoteModel): model is UsableModel {
|
||||
return (
|
||||
model.policy?.state !== "disabled" &&
|
||||
model.capabilities.limits?.max_output_tokens !== undefined &&
|
||||
model.capabilities.limits.max_prompt_tokens !== undefined &&
|
||||
model.capabilities.supports.tool_calls !== undefined
|
||||
)
|
||||
}
|
||||
|
||||
function build(id: ModelV2.ID, remote: UsableModel, baseURL: string, previous?: ModelV2.Info) {
|
||||
const messages = remote.supported_endpoints?.includes("/v1/messages") ?? false
|
||||
const endpoint = messages
|
||||
? "messages"
|
||||
: remote.supported_endpoints?.includes("/responses")
|
||||
? "responses"
|
||||
: remote.supported_endpoints?.includes("/chat/completions")
|
||||
? "chat"
|
||||
: undefined
|
||||
const image =
|
||||
(remote.capabilities.supports.vision ?? false) ||
|
||||
(remote.capabilities.limits.vision?.supported_media_types ?? []).some((item) => item.startsWith("image/"))
|
||||
const prices = remote.billing?.token_prices
|
||||
// Copilot reports AIC per billing batch; OpenCode stores USD per million tokens.
|
||||
const usdPerMillion = prices && prices.batch_size > 0 ? 10_000 / prices.batch_size : 0
|
||||
const version = remote.version.startsWith(`${remote.id}-`)
|
||||
? remote.version.slice(remote.id.length + 1)
|
||||
: remote.version
|
||||
const released = previous?.time.released || Date.parse(version)
|
||||
|
||||
return ModelV2.Info.make({
|
||||
...ModelV2.Info.empty(ProviderV2.ID.githubCopilot, id),
|
||||
id,
|
||||
modelID: ModelV2.ID.make(remote.id),
|
||||
providerID: ProviderV2.ID.githubCopilot,
|
||||
family: previous?.family ?? ModelV2.Family.make(remote.capabilities.family),
|
||||
name: previous?.name ?? remote.name,
|
||||
package: ProviderV2.aisdk(messages ? "@ai-sdk/anthropic" : "@ai-sdk/github-copilot"),
|
||||
settings: ProviderV2.mergeOverlay(previous?.settings, {
|
||||
baseURL: messages ? `${baseURL}/v1` : baseURL,
|
||||
...(endpoint ? { endpoint } : {}),
|
||||
}),
|
||||
headers: previous?.headers,
|
||||
body: previous?.body,
|
||||
capabilities: {
|
||||
tools: remote.capabilities.supports.tool_calls,
|
||||
input: image ? ["text", "image"] : ["text"],
|
||||
output: ["text"],
|
||||
},
|
||||
variants: variants(remote, messages),
|
||||
time: { released: Number.isFinite(released) ? released : 0 },
|
||||
cost: [
|
||||
{
|
||||
input: Money.USDPerMillionTokens.make((prices?.default.input_price ?? 0) * usdPerMillion),
|
||||
output: Money.USDPerMillionTokens.make((prices?.default.output_price ?? 0) * usdPerMillion),
|
||||
cache: {
|
||||
read: Money.USDPerMillionTokens.make((prices?.default.cache_price ?? 0) * usdPerMillion),
|
||||
write: Money.USDPerMillionTokens.zero,
|
||||
},
|
||||
},
|
||||
],
|
||||
status: "active",
|
||||
enabled: remote.model_picker_enabled,
|
||||
limit: {
|
||||
context: remote.capabilities.limits.max_context_window_tokens ?? remote.capabilities.limits.max_prompt_tokens,
|
||||
input: remote.capabilities.limits.max_prompt_tokens,
|
||||
output: remote.capabilities.limits.max_output_tokens,
|
||||
},
|
||||
})
|
||||
}
|
||||
|
||||
function variants(remote: UsableModel, messages: boolean): ModelV2.Info["variants"] {
|
||||
const efforts = remote.capabilities.supports.reasoning_effort ?? []
|
||||
if (!messages && efforts.length) {
|
||||
return efforts.map((effort) => ({
|
||||
id: ModelV2.VariantID.make(effort),
|
||||
settings: {
|
||||
reasoningEffort: effort,
|
||||
reasoningSummary: "auto",
|
||||
include: ["reasoning.encrypted_content"],
|
||||
},
|
||||
}))
|
||||
}
|
||||
if (efforts.length && remote.capabilities.supports.adaptive_thinking) {
|
||||
return efforts.map((effort) => ({
|
||||
id: ModelV2.VariantID.make(effort),
|
||||
settings: {
|
||||
thinking: {
|
||||
type: "adaptive",
|
||||
...(remote.id.includes("opus-4.7") ? { display: "summarized" } : {}),
|
||||
},
|
||||
effort,
|
||||
},
|
||||
}))
|
||||
}
|
||||
const max = remote.capabilities.supports.max_thinking_budget
|
||||
if (max === undefined) return []
|
||||
return [
|
||||
{
|
||||
id: ModelV2.VariantID.make("max"),
|
||||
settings: { thinking: { type: "enabled", budgetTokens: max - 1 } },
|
||||
},
|
||||
{
|
||||
id: ModelV2.VariantID.make("high"),
|
||||
settings: { thinking: { type: "enabled", budgetTokens: Math.floor(max / 2) } },
|
||||
},
|
||||
]
|
||||
}
|
||||
@@ -21,10 +21,14 @@ import { ToolHooks } from "./tool/hooks"
|
||||
import { PluginHooks } from "./plugin/hooks"
|
||||
|
||||
export interface Interface {
|
||||
readonly activate: (plugins: readonly Plugin[]) => Effect.Effect<void>
|
||||
readonly activate: (plugins: readonly Versioned[]) => Effect.Effect<void>
|
||||
readonly list: () => Effect.Effect<Info[]>
|
||||
}
|
||||
|
||||
export interface Versioned extends Plugin {
|
||||
readonly version: string
|
||||
}
|
||||
|
||||
export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Plugin") {}
|
||||
|
||||
const layer = Layer.effect(
|
||||
@@ -32,11 +36,11 @@ const layer = Layer.effect(
|
||||
Effect.gen(function* () {
|
||||
const events = yield* EventV2.Service
|
||||
const scope = yield* Scope.make()
|
||||
const active = new Map<typeof ID.Type, { readonly plugin: Plugin; readonly scope: Scope.Closeable }>()
|
||||
const active = new Map<typeof ID.Type, { readonly plugin: Versioned; readonly scope: Scope.Closeable }>()
|
||||
const lock = Semaphore.makeUnsafe(1)
|
||||
let host: Parameters<Plugin["effect"]>[0]
|
||||
|
||||
const load = Effect.fnUntraced(function* (plugin: Plugin) {
|
||||
const load = Effect.fnUntraced(function* (plugin: Versioned) {
|
||||
const child = yield* Scope.fork(scope)
|
||||
const inherit = yield* State.inherit()
|
||||
const loaded = yield* Effect.suspend(() => plugin.effect(host)).pipe(
|
||||
@@ -55,7 +59,7 @@ const layer = Layer.effect(
|
||||
return undefined
|
||||
})
|
||||
|
||||
const activate = Effect.fn("Plugin.activate")(function* (plugins: readonly Plugin[]) {
|
||||
const activate = Effect.fn("Plugin.activate")(function* (plugins: readonly Versioned[]) {
|
||||
const definitions = plugins.map((plugin) => ({ ...plugin, id: ID.make(plugin.id) }))
|
||||
const ids = new Set<typeof ID.Type>()
|
||||
for (const definition of definitions) {
|
||||
@@ -65,6 +69,20 @@ const layer = Layer.effect(
|
||||
|
||||
yield* lock.withPermit(
|
||||
Effect.gen(function* () {
|
||||
const next = definitions.map((definition) => ({ id: definition.id, version: definition.version }))
|
||||
const current = Array.from(active.values(), (entry) => ({
|
||||
id: entry.plugin.id,
|
||||
version: entry.plugin.version,
|
||||
}))
|
||||
if (
|
||||
current.length === next.length &&
|
||||
current.every((definition, index) => {
|
||||
const candidate = next[index]
|
||||
return definition.id === candidate?.id && definition.version === candidate.version
|
||||
})
|
||||
)
|
||||
return
|
||||
|
||||
yield* State.batch(
|
||||
Effect.gen(function* () {
|
||||
for (const definition of definitions) {
|
||||
|
||||
@@ -378,6 +378,7 @@ export const make = Effect.fn("PluginHost.make")(function* (plugin: PluginV2.Int
|
||||
get: (input) => runtime.session.get(input.sessionID),
|
||||
prompt: runtime.session.prompt,
|
||||
command: runtime.session.command,
|
||||
rename: runtime.session.rename,
|
||||
interrupt: (input) => runtime.session.interrupt(input.sessionID),
|
||||
},
|
||||
} satisfies Plugin.Context
|
||||
|
||||
@@ -38,7 +38,6 @@ import { QuestionTool } from "../tool/question"
|
||||
import { ReadToolFileSystem } from "../tool/read-filesystem"
|
||||
import { ReadTool } from "../tool/read"
|
||||
import { ShellTool } from "../tool/shell"
|
||||
import { SearchFixtureTool } from "../tool/search-fixture"
|
||||
import { SkillTool } from "../tool/skill"
|
||||
import { SubagentTool } from "../tool/subagent"
|
||||
import { Tools } from "../tool/tools"
|
||||
@@ -130,7 +129,6 @@ const pre = [
|
||||
GrepTool.Plugin,
|
||||
QuestionTool.Plugin,
|
||||
ReadTool.Plugin,
|
||||
SearchFixtureTool.Plugin,
|
||||
ShellTool.Plugin,
|
||||
SkillTool.Plugin,
|
||||
SubagentTool.Plugin,
|
||||
|
||||
@@ -70,7 +70,8 @@ export function fromPromise(plugin: Plugin) {
|
||||
catalog: {
|
||||
provider: {
|
||||
list: (input) => run(host.catalog.provider.list(input)),
|
||||
get: (input) => run(host.catalog.provider.get({ ...input, providerID: Provider.ID.make(input.providerID) })),
|
||||
get: (input) =>
|
||||
run(host.catalog.provider.get({ ...input, providerID: Provider.ID.make(input.providerID) })),
|
||||
},
|
||||
model: {
|
||||
list: (input) => run(host.catalog.model.list(input)),
|
||||
@@ -96,7 +97,9 @@ export function fromPromise(plugin: Plugin) {
|
||||
),
|
||||
connect: {
|
||||
key: (input) =>
|
||||
run(host.integration.connect.key({ ...input, integrationID: Integration.ID.make(input.integrationID) })),
|
||||
run(
|
||||
host.integration.connect.key({ ...input, integrationID: Integration.ID.make(input.integrationID) }),
|
||||
),
|
||||
oauth: (input) =>
|
||||
run(
|
||||
host.integration.connect.oauth({
|
||||
@@ -208,6 +211,13 @@ export function fromPromise(plugin: Plugin) {
|
||||
resume: input.resume ?? undefined,
|
||||
}),
|
||||
),
|
||||
rename: (input) =>
|
||||
run(
|
||||
host.session.rename({
|
||||
...input,
|
||||
sessionID: Session.ID.make(input.sessionID),
|
||||
}),
|
||||
),
|
||||
interrupt: (input) => run(host.session.interrupt({ sessionID: Session.ID.make(input.sessionID) })),
|
||||
},
|
||||
}
|
||||
|
||||
@@ -1,7 +1,115 @@
|
||||
import { Effect } from "effect"
|
||||
import type { IntegrationOAuthMethodRegistration } from "@opencode-ai/plugin/v2/effect/integration"
|
||||
import { Effect, Option, Schema, Semaphore, Stream } from "effect"
|
||||
import { Catalog } from "../../catalog"
|
||||
import { Credential } from "../../credential"
|
||||
import { EventV2 } from "../../event"
|
||||
import { CopilotModels } from "../../github-copilot/models"
|
||||
import { InstallationVersion } from "../../installation/version"
|
||||
import { Integration } from "../../integration"
|
||||
import { ModelV2 } from "../../model"
|
||||
import { define } from "@opencode-ai/plugin/v2/effect/plugin"
|
||||
import { ProviderV2 } from "../../provider"
|
||||
import type { PluginInternal } from "../internal"
|
||||
|
||||
const clientID = "Ov23li8tweQw6odWQebz"
|
||||
const apiVersion = "2026-06-01"
|
||||
const pollingSafetyMargin = 3000
|
||||
const methodID = Integration.MethodID.make("device")
|
||||
|
||||
const Device = Schema.Struct({
|
||||
verification_uri: Schema.String,
|
||||
user_code: Schema.String,
|
||||
device_code: Schema.String,
|
||||
interval: Schema.Number,
|
||||
})
|
||||
const Token = Schema.Struct({
|
||||
access_token: Schema.optional(Schema.String),
|
||||
error: Schema.optional(Schema.String),
|
||||
interval: Schema.optional(Schema.Number),
|
||||
})
|
||||
const JsonBody = Schema.UnknownFromJsonString
|
||||
const decodeBody = Schema.decodeUnknownOption(JsonBody)
|
||||
|
||||
const oauth = {
|
||||
integrationID: Integration.ID.make("github-copilot"),
|
||||
method: {
|
||||
id: methodID,
|
||||
type: "oauth",
|
||||
label: "Login with GitHub Copilot",
|
||||
prompts: [
|
||||
{
|
||||
type: "select",
|
||||
key: "deploymentType",
|
||||
message: "Select GitHub deployment type",
|
||||
options: [
|
||||
{ label: "GitHub.com", value: "github.com", hint: "Public" },
|
||||
{ label: "GitHub Enterprise", value: "enterprise", hint: "Data residency or self-hosted" },
|
||||
],
|
||||
},
|
||||
{
|
||||
type: "text",
|
||||
key: "enterpriseUrl",
|
||||
message: "Enter your GitHub Enterprise URL or domain",
|
||||
placeholder: "company.ghe.com or https://company.ghe.com",
|
||||
when: { key: "deploymentType", op: "eq", value: "enterprise" },
|
||||
},
|
||||
],
|
||||
},
|
||||
authorize: (inputs) =>
|
||||
Effect.gen(function* () {
|
||||
const enterprise = inputs.deploymentType === "enterprise"
|
||||
if (enterprise && !inputs.enterpriseUrl) return yield* Effect.fail(new Error("Enterprise URL is required"))
|
||||
const domain = enterprise ? normalizeDomain(inputs.enterpriseUrl ?? "") : "github.com"
|
||||
const urls = oauthURLs(domain)
|
||||
const device = yield* request(urls.device, {
|
||||
method: "POST",
|
||||
headers: headers(),
|
||||
body: JSON.stringify({ client_id: clientID, scope: "read:user" }),
|
||||
}).pipe(Effect.map(Schema.decodeUnknownSync(Device)))
|
||||
const interval = Math.max(device.interval, 1) * 1000
|
||||
|
||||
const poll = (wait: number): Effect.Effect<Credential.OAuth, unknown> =>
|
||||
request(urls.token, {
|
||||
method: "POST",
|
||||
headers: headers(),
|
||||
body: JSON.stringify({
|
||||
client_id: clientID,
|
||||
device_code: device.device_code,
|
||||
grant_type: "urn:ietf:params:oauth:grant-type:device_code",
|
||||
}),
|
||||
}).pipe(
|
||||
Effect.map(Schema.decodeUnknownSync(Token)),
|
||||
Effect.flatMap((token) => {
|
||||
if (token.access_token) {
|
||||
return Effect.succeed(
|
||||
Credential.OAuth.make({
|
||||
type: "oauth",
|
||||
methodID,
|
||||
refresh: token.access_token,
|
||||
access: token.access_token,
|
||||
expires: 0,
|
||||
...(enterprise ? { metadata: { enterpriseUrl: domain } } : {}),
|
||||
}),
|
||||
)
|
||||
}
|
||||
if (token.error === "authorization_pending")
|
||||
return Effect.sleep(wait + pollingSafetyMargin).pipe(Effect.andThen(poll(wait)))
|
||||
if (token.error === "slow_down") {
|
||||
const next = token.interval && token.interval > 0 ? token.interval * 1000 : wait + 5000
|
||||
return Effect.sleep(next + pollingSafetyMargin).pipe(Effect.andThen(poll(next)))
|
||||
}
|
||||
return Effect.fail(new Error(`Device authorization failed${token.error ? `: ${token.error}` : ""}`))
|
||||
}),
|
||||
)
|
||||
|
||||
return {
|
||||
mode: "auto" as const,
|
||||
url: device.verification_uri,
|
||||
instructions: `Enter code: ${device.user_code}`,
|
||||
callback: poll(interval),
|
||||
}
|
||||
}),
|
||||
} satisfies IntegrationOAuthMethodRegistration
|
||||
|
||||
function shouldUseResponses(modelID: string) {
|
||||
// Copilot supports Responses for GPT-5 class models, except mini variants
|
||||
@@ -14,19 +122,103 @@ function shouldUseResponses(modelID: string) {
|
||||
export const GithubCopilotPlugin = define({
|
||||
id: "opencode.provider.github-copilot",
|
||||
effect: Effect.fn(function* (ctx) {
|
||||
const catalog = yield* Catalog.Service
|
||||
const events = yield* EventV2.Service
|
||||
const loading = Semaphore.makeUnsafe(1)
|
||||
const loaded: {
|
||||
baseURL?: string
|
||||
models?: Map<ModelV2.ID, ModelV2.Info>
|
||||
} = {}
|
||||
|
||||
const load = Effect.fn("GithubCopilotPlugin.load")(function* () {
|
||||
const connection = yield* ctx.integration.connection.active("github-copilot")
|
||||
const credential = connection
|
||||
? yield* ctx.integration.connection.resolve(connection).pipe(Effect.catch(() => Effect.succeed(undefined)))
|
||||
: undefined
|
||||
if (credential?.type !== "oauth") {
|
||||
loaded.baseURL = undefined
|
||||
loaded.models = undefined
|
||||
return
|
||||
}
|
||||
|
||||
const enterprise = credential.metadata?.enterpriseUrl
|
||||
loaded.baseURL = baseURL(typeof enterprise === "string" ? enterprise : undefined)
|
||||
const provider = yield* catalog.provider.get(ProviderV2.ID.githubCopilot)
|
||||
const existing = (yield* catalog.model.all()).filter((model) => model.providerID === ProviderV2.ID.githubCopilot)
|
||||
loaded.models = yield* Effect.tryPromise({
|
||||
try: () =>
|
||||
CopilotModels.get(
|
||||
loaded.baseURL ?? baseURL(),
|
||||
{
|
||||
...provider?.headers,
|
||||
Authorization: `Bearer ${credential.refresh}`,
|
||||
"User-Agent": `opencode/${InstallationVersion}`,
|
||||
"X-GitHub-Api-Version": apiVersion,
|
||||
},
|
||||
existing,
|
||||
),
|
||||
catch: (cause) => cause,
|
||||
}).pipe(
|
||||
Effect.catch((cause) =>
|
||||
Effect.logWarning("failed to sync GitHub Copilot models", { cause }).pipe(Effect.as(undefined)),
|
||||
),
|
||||
)
|
||||
})
|
||||
|
||||
yield* ctx.integration.transform((draft) => {
|
||||
draft.method.update(oauth)
|
||||
})
|
||||
yield* ctx.catalog.transform((evt) => {
|
||||
const item = evt.provider.get(ProviderV2.ID.githubCopilot)
|
||||
if (!item || !item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) return
|
||||
evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
|
||||
// This chat-only alias conflicts with the Copilot GPT-5 Responses route,
|
||||
// so hide it only for Copilot rather than for every provider catalog.
|
||||
model.enabled = false
|
||||
})
|
||||
if (!item) return
|
||||
if (loaded.models) {
|
||||
for (const id of item.models.keys()) {
|
||||
if (!loaded.models.has(ModelV2.ID.make(id))) evt.model.remove(item.provider.id, id)
|
||||
}
|
||||
for (const [id, model] of loaded.models) {
|
||||
evt.model.update(item.provider.id, id, (draft) => Object.assign(draft, structuredClone(model)))
|
||||
}
|
||||
} else if (loaded.baseURL) {
|
||||
for (const id of item.models.keys()) {
|
||||
evt.model.update(item.provider.id, id, (model) => {
|
||||
model.settings = ProviderV2.mergeOverlay(model.settings, { baseURL: loaded.baseURL })
|
||||
})
|
||||
}
|
||||
}
|
||||
if (item.models.has(ModelV2.ID.make("gpt-5-chat-latest"))) {
|
||||
evt.model.update(item.provider.id, ModelV2.ID.make("gpt-5-chat-latest"), (model) => {
|
||||
// This chat-only alias conflicts with the Copilot GPT-5 Responses route,
|
||||
// so hide it only for Copilot rather than for every provider catalog.
|
||||
model.enabled = false
|
||||
})
|
||||
}
|
||||
})
|
||||
const refresh = () => loading.withPermit(load().pipe(Effect.andThen(ctx.catalog.reload())))
|
||||
yield* events.subscribe(Integration.Event.ConnectionUpdated).pipe(
|
||||
Stream.filter((event) => event.data.integrationID === Integration.ID.make("github-copilot")),
|
||||
Stream.runForEach(refresh),
|
||||
Effect.forkScoped({ startImmediately: true }),
|
||||
)
|
||||
yield* refresh().pipe(Effect.forkScoped)
|
||||
yield* ctx.aisdk.hook(
|
||||
"sdk",
|
||||
Effect.fn(function* (evt) {
|
||||
if (evt.package !== "@ai-sdk/github-copilot") return
|
||||
if (evt.model.providerID !== ProviderV2.ID.githubCopilot) return
|
||||
if (evt.package !== "@ai-sdk/github-copilot" && evt.package !== "@ai-sdk/anthropic") return
|
||||
evt.options.fetch = copilotFetch(
|
||||
typeof evt.options.apiKey === "string" ? evt.options.apiKey : undefined,
|
||||
evt.options.fetch,
|
||||
evt.package === "@ai-sdk/anthropic",
|
||||
)
|
||||
if (evt.package === "@ai-sdk/anthropic") {
|
||||
evt.options.headers = {
|
||||
...evt.options.headers,
|
||||
"anthropic-beta": "interleaved-thinking-2025-05-14",
|
||||
}
|
||||
const mod = yield* Effect.promise(() => import("@ai-sdk/anthropic"))
|
||||
evt.sdk = mod.createAnthropic(evt.options)
|
||||
return
|
||||
}
|
||||
const mod = yield* Effect.promise(() => import("../../github-copilot/copilot-provider"))
|
||||
evt.sdk = mod.createOpenaiCompatible(evt.options)
|
||||
}),
|
||||
@@ -52,4 +244,114 @@ export const GithubCopilotPlugin = define({
|
||||
}),
|
||||
)
|
||||
}),
|
||||
})
|
||||
} satisfies PluginInternal.InternalPlugin)
|
||||
|
||||
function normalizeDomain(input: string) {
|
||||
return input.replace(/^https?:\/\//, "").replace(/\/$/, "")
|
||||
}
|
||||
|
||||
function oauthURLs(domain: string) {
|
||||
return {
|
||||
device: `https://${domain}/login/device/code`,
|
||||
token: `https://${domain}/login/oauth/access_token`,
|
||||
}
|
||||
}
|
||||
|
||||
function baseURL(enterprise?: string) {
|
||||
return enterprise ? `https://copilot-api.${normalizeDomain(enterprise)}` : "https://api.githubcopilot.com"
|
||||
}
|
||||
|
||||
function headers() {
|
||||
return {
|
||||
Accept: "application/json",
|
||||
"Content-Type": "application/json",
|
||||
"User-Agent": `opencode/${InstallationVersion}`,
|
||||
}
|
||||
}
|
||||
|
||||
function request(url: string, init: RequestInit) {
|
||||
return Effect.tryPromise({
|
||||
try: async (signal) => {
|
||||
const response = await fetch(url, { ...init, signal })
|
||||
if (!response.ok) throw new Error(`Request failed: ${response.status}`)
|
||||
return response.json()
|
||||
},
|
||||
catch: (cause) => cause,
|
||||
})
|
||||
}
|
||||
|
||||
type Fetch = (input: Parameters<typeof fetch>[0], init?: RequestInit) => Promise<Response>
|
||||
|
||||
export function copilotFetch(token: string | undefined, upstream: Fetch | undefined, anthropic: boolean): Fetch {
|
||||
const send = upstream ?? fetch
|
||||
return async (input, init) => {
|
||||
const requestHeaders = new Headers(init?.headers)
|
||||
if (token) {
|
||||
requestHeaders.delete("authorization")
|
||||
requestHeaders.delete("x-api-key")
|
||||
requestHeaders.set("Authorization", `Bearer ${token}`)
|
||||
}
|
||||
requestHeaders.set("User-Agent", `opencode/${InstallationVersion}`)
|
||||
requestHeaders.set("Openai-Intent", "conversation-edits")
|
||||
requestHeaders.set("X-GitHub-Api-Version", apiVersion)
|
||||
if (anthropic) requestHeaders.set("anthropic-beta", "interleaved-thinking-2025-05-14")
|
||||
|
||||
const url = input instanceof URL ? input.href : typeof input === "string" ? input : input.url
|
||||
const body = typeof init?.body === "string" ? Option.getOrUndefined(decodeBody(init.body)) : undefined
|
||||
const metadata = requestMetadata(url, body)
|
||||
requestHeaders.set("x-initiator", metadata.agent ? "agent" : "user")
|
||||
if (metadata.vision) requestHeaders.set("Copilot-Vision-Request", "true")
|
||||
return send(input, { ...init, headers: requestHeaders })
|
||||
}
|
||||
}
|
||||
|
||||
function requestMetadata(url: string, body: unknown) {
|
||||
if (!record(body)) return { agent: false, vision: false }
|
||||
if (Array.isArray(body.input)) {
|
||||
const last = body.input.at(-1)
|
||||
return {
|
||||
agent: !record(last) || last.role !== "user",
|
||||
vision: body.input.some(
|
||||
(item) =>
|
||||
record(item) &&
|
||||
Array.isArray(item.content) &&
|
||||
item.content.some((part) => record(part) && part.type === "input_image"),
|
||||
),
|
||||
}
|
||||
}
|
||||
if (!Array.isArray(body.messages)) return { agent: false, vision: false }
|
||||
const last = body.messages.at(-1)
|
||||
if (url.includes("completions")) {
|
||||
return {
|
||||
agent: !record(last) || last.role !== "user",
|
||||
vision: body.messages.some(
|
||||
(message) =>
|
||||
record(message) &&
|
||||
Array.isArray(message.content) &&
|
||||
message.content.some((part) => record(part) && part.type === "image_url"),
|
||||
),
|
||||
}
|
||||
}
|
||||
const content = record(last) && Array.isArray(last.content) ? last.content : []
|
||||
return {
|
||||
agent:
|
||||
!record(last) || last.role !== "user" || !content.some((part) => record(part) && part.type !== "tool_result"),
|
||||
vision: body.messages.some(
|
||||
(message) =>
|
||||
record(message) &&
|
||||
Array.isArray(message.content) &&
|
||||
message.content.some(
|
||||
(part) =>
|
||||
record(part) &&
|
||||
(part.type === "image" ||
|
||||
(part.type === "tool_result" &&
|
||||
Array.isArray(part.content) &&
|
||||
part.content.some((nested) => record(nested) && nested.type === "image"))),
|
||||
),
|
||||
),
|
||||
}
|
||||
}
|
||||
|
||||
function record(input: unknown): input is Record<string, unknown> {
|
||||
return typeof input === "object" && input !== null && !Array.isArray(input)
|
||||
}
|
||||
|
||||
@@ -11,7 +11,7 @@ import { SessionV2 } from "../session"
|
||||
export interface Interface {
|
||||
readonly session: Pick<
|
||||
SessionV2.Interface,
|
||||
"get" | "create" | "messages" | "prompt" | "command" | "resume" | "interrupt" | "synthetic"
|
||||
"get" | "create" | "messages" | "prompt" | "command" | "rename" | "resume" | "interrupt" | "synthetic"
|
||||
>
|
||||
readonly job: Pick<Job.Interface, "start" | "wait" | "block" | "background" | "cancel">
|
||||
readonly location: {
|
||||
@@ -51,6 +51,7 @@ export const layerWithCell = (cell: Cell) =>
|
||||
messages: (input) => require(cell, (runtime) => runtime.session.messages(input)),
|
||||
prompt: (input) => require(cell, (runtime) => runtime.session.prompt(input)),
|
||||
command: (input) => require(cell, (runtime) => runtime.session.command(input)),
|
||||
rename: (input) => require(cell, (runtime) => runtime.session.rename(input)),
|
||||
resume: (sessionID) => require(cell, (runtime) => runtime.session.resume(sessionID)),
|
||||
interrupt: (sessionID) => require(cell, (runtime) => runtime.session.interrupt(sessionID)),
|
||||
synthetic: (input) => require(cell, (runtime) => runtime.session.synthetic(input)),
|
||||
|
||||
@@ -4,6 +4,7 @@ import type { Plugin } from "@opencode-ai/plugin/v2/effect/plugin"
|
||||
import { Context, Effect, Layer } from "effect"
|
||||
import { makeGlobalNode } from "../effect/app-node"
|
||||
import { EventV2 } from "../event"
|
||||
import type { PluginV2 } from "../plugin"
|
||||
|
||||
export const Updated = EventV2.ephemeral({ type: "sdk.plugin.updated", schema: {} })
|
||||
|
||||
@@ -20,7 +21,7 @@ export const Updated = EventV2.ephemeral({ type: "sdk.plugin.updated", schema: {
|
||||
*/
|
||||
export interface Interface {
|
||||
readonly register: (plugin: Plugin) => Effect.Effect<void>
|
||||
readonly all: () => readonly Plugin[]
|
||||
readonly all: () => readonly PluginV2.Versioned[]
|
||||
}
|
||||
|
||||
export class Service extends Context.Service<Service, Interface>()("@opencode/SdkPlugins") {}
|
||||
@@ -29,11 +30,12 @@ export const layer = Layer.effect(
|
||||
Service,
|
||||
Effect.gen(function* () {
|
||||
const events = yield* EventV2.Service
|
||||
const plugins = new Map<string, Plugin>()
|
||||
const plugins = new Map<string, PluginV2.Versioned>()
|
||||
let revision = 0
|
||||
return Service.of({
|
||||
register: (plugin) =>
|
||||
Effect.sync(() => {
|
||||
plugins.set(plugin.id, plugin)
|
||||
plugins.set(plugin.id, { ...plugin, version: String(++revision) })
|
||||
}).pipe(Effect.andThen(events.publish(Updated, {})), Effect.asVoid),
|
||||
all: () => [...plugins.values()],
|
||||
})
|
||||
|
||||
@@ -116,15 +116,15 @@ const scan = Effect.fn("PluginSupervisor.scan")(function* (entries: readonly Con
|
||||
})
|
||||
|
||||
const resolve = Effect.fn("PluginSupervisor.resolve")(function* (
|
||||
pre: readonly Plugin[],
|
||||
post: readonly Plugin[],
|
||||
pre: readonly PluginV2.Versioned[],
|
||||
post: readonly PluginV2.Versioned[],
|
||||
operations: readonly Operation[],
|
||||
) {
|
||||
const matches = (selector: string, target: string) =>
|
||||
selector === "*" || (selector.endsWith(".*") ? target.startsWith(selector.slice(0, -1)) : selector === target)
|
||||
const definitions = [...pre, ...post]
|
||||
const enabled = new Set(definitions.map((plugin) => plugin.id))
|
||||
const packages = new Map<string, Plugin>()
|
||||
const packages = new Map<string, PluginV2.Versioned>()
|
||||
const plugins = () => [...definitions, ...packages.values()]
|
||||
|
||||
for (const operation of operations) {
|
||||
@@ -178,8 +178,9 @@ const load = Effect.fn("PluginSupervisor.load")(function* (operation: Extract<Op
|
||||
const plugin = "effect" in value ? value : PluginPromise.fromPromise(value)
|
||||
return {
|
||||
id: plugin.id,
|
||||
version: JSON.stringify(operation),
|
||||
effect: (host) => plugin.effect({ ...host, options: operation.options }),
|
||||
} satisfies Plugin
|
||||
} satisfies PluginV2.Versioned
|
||||
})
|
||||
|
||||
function discoverDirectory(fs: FSUtil.Interface, directory: string) {
|
||||
@@ -253,10 +254,11 @@ const layer = Layer.effect(
|
||||
// Resolve OpenCode's internal plugins with their privileged Location services.
|
||||
const internal = yield* PluginInternal.list()
|
||||
// Combine internal plugins with host-contributed SDK plugins in boot order.
|
||||
const pre = [...internal.pre, ...sdk.all()]
|
||||
const pre = [...internal.pre.map((plugin) => ({ ...plugin, version: "internal" })), ...sdk.all()]
|
||||
const post = internal.post.map((plugin) => ({ ...plugin, version: "internal" }))
|
||||
const operations = yield* scan(yield* config.entries())
|
||||
// Apply config operations and load enabled package plugins into one ordered generation.
|
||||
const plugins = yield* resolve(pre, internal.post, operations)
|
||||
const plugins = yield* resolve(pre, post, operations)
|
||||
// Replace the active generation in one scoped, batched activation.
|
||||
yield* registry.activate(plugins)
|
||||
applied = target
|
||||
|
||||
@@ -92,6 +92,7 @@ const layer = Layer.effect(
|
||||
},
|
||||
list: () => draft.sources as Source[],
|
||||
}),
|
||||
finalize: () => events.publish(Event.Updated, {}).pipe(Effect.asVoid),
|
||||
})
|
||||
|
||||
const load = Effect.fn("SkillV2.load")(function* (source: Source) {
|
||||
|
||||
@@ -1,355 +0,0 @@
|
||||
export * as SearchFixtureTool from "./search-fixture"
|
||||
|
||||
import type { Context as PluginContext } from "@opencode-ai/plugin/v2/effect/plugin"
|
||||
import { Effect, Schema } from "effect"
|
||||
import { Tool } from "./tool"
|
||||
|
||||
export const catalog = [
|
||||
{
|
||||
namespace: "slack",
|
||||
label: "Slack",
|
||||
operations: [
|
||||
"send_message",
|
||||
"schedule_message",
|
||||
"create_channel",
|
||||
"archive_channel",
|
||||
"invite_user",
|
||||
"add_reaction",
|
||||
"pin_message",
|
||||
"set_topic",
|
||||
"start_huddle",
|
||||
"export_thread",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "github",
|
||||
label: "GitHub",
|
||||
operations: [
|
||||
"create_issue",
|
||||
"close_issue",
|
||||
"assign_issue",
|
||||
"label_issue",
|
||||
"create_pull_request",
|
||||
"request_review",
|
||||
"merge_pull_request",
|
||||
"create_release",
|
||||
"dispatch_workflow",
|
||||
"protect_branch",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "linear",
|
||||
label: "Linear",
|
||||
operations: [
|
||||
"create_issue",
|
||||
"update_issue",
|
||||
"assign_issue",
|
||||
"move_issue",
|
||||
"add_comment",
|
||||
"create_project",
|
||||
"update_project",
|
||||
"create_cycle",
|
||||
"add_label",
|
||||
"archive_issue",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "notion",
|
||||
label: "Notion",
|
||||
operations: [
|
||||
"create_page",
|
||||
"update_page",
|
||||
"archive_page",
|
||||
"search_workspace",
|
||||
"append_blocks",
|
||||
"create_database",
|
||||
"add_database_row",
|
||||
"update_database_row",
|
||||
"duplicate_page",
|
||||
"share_page",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "jira",
|
||||
label: "Jira",
|
||||
operations: [
|
||||
"create_ticket",
|
||||
"transition_ticket",
|
||||
"assign_ticket",
|
||||
"add_comment",
|
||||
"link_ticket",
|
||||
"create_epic",
|
||||
"add_to_sprint",
|
||||
"log_work",
|
||||
"set_priority",
|
||||
"close_ticket",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "google_drive",
|
||||
label: "Google Drive",
|
||||
operations: [
|
||||
"create_folder",
|
||||
"upload_file",
|
||||
"move_file",
|
||||
"copy_file",
|
||||
"share_file",
|
||||
"revoke_access",
|
||||
"rename_file",
|
||||
"trash_file",
|
||||
"restore_file",
|
||||
"search_files",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "gmail",
|
||||
label: "Gmail",
|
||||
operations: [
|
||||
"send_email",
|
||||
"create_draft",
|
||||
"reply_thread",
|
||||
"forward_email",
|
||||
"add_label",
|
||||
"remove_label",
|
||||
"archive_thread",
|
||||
"mark_read",
|
||||
"mark_unread",
|
||||
"schedule_email",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "calendar",
|
||||
label: "Google Calendar",
|
||||
operations: [
|
||||
"create_event",
|
||||
"update_event",
|
||||
"cancel_event",
|
||||
"invite_attendee",
|
||||
"remove_attendee",
|
||||
"find_availability",
|
||||
"reserve_room",
|
||||
"add_conference",
|
||||
"set_reminder",
|
||||
"list_events",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "stripe",
|
||||
label: "Stripe",
|
||||
operations: [
|
||||
"create_customer",
|
||||
"update_customer",
|
||||
"create_invoice",
|
||||
"finalize_invoice",
|
||||
"refund_payment",
|
||||
"cancel_subscription",
|
||||
"pause_subscription",
|
||||
"resume_subscription",
|
||||
"create_coupon",
|
||||
"send_receipt",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "salesforce",
|
||||
label: "Salesforce",
|
||||
operations: [
|
||||
"create_lead",
|
||||
"convert_lead",
|
||||
"update_contact",
|
||||
"create_account",
|
||||
"update_opportunity",
|
||||
"advance_opportunity",
|
||||
"add_activity",
|
||||
"create_case",
|
||||
"close_case",
|
||||
"assign_owner",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "hubspot",
|
||||
label: "HubSpot",
|
||||
operations: [
|
||||
"create_contact",
|
||||
"update_contact",
|
||||
"create_company",
|
||||
"create_deal",
|
||||
"move_deal_stage",
|
||||
"enroll_workflow",
|
||||
"add_note",
|
||||
"create_task",
|
||||
"merge_contacts",
|
||||
"assign_owner",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "zendesk",
|
||||
label: "Zendesk",
|
||||
operations: [
|
||||
"create_ticket",
|
||||
"update_ticket",
|
||||
"assign_ticket",
|
||||
"add_internal_note",
|
||||
"reply_ticket",
|
||||
"set_priority",
|
||||
"add_tag",
|
||||
"remove_tag",
|
||||
"merge_ticket",
|
||||
"solve_ticket",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "datadog",
|
||||
label: "Datadog",
|
||||
operations: [
|
||||
"create_monitor",
|
||||
"mute_monitor",
|
||||
"unmute_monitor",
|
||||
"create_dashboard",
|
||||
"add_dashboard_widget",
|
||||
"annotate_event",
|
||||
"create_incident",
|
||||
"update_incident",
|
||||
"resolve_incident",
|
||||
"schedule_downtime",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "pagerduty",
|
||||
label: "PagerDuty",
|
||||
operations: [
|
||||
"trigger_incident",
|
||||
"acknowledge_incident",
|
||||
"resolve_incident",
|
||||
"reassign_incident",
|
||||
"add_responder",
|
||||
"add_note",
|
||||
"create_escalation_policy",
|
||||
"override_schedule",
|
||||
"create_maintenance_window",
|
||||
"snooze_incident",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "aws",
|
||||
label: "AWS",
|
||||
operations: [
|
||||
"launch_instance",
|
||||
"stop_instance",
|
||||
"restart_instance",
|
||||
"scale_service",
|
||||
"deploy_lambda",
|
||||
"invalidate_cache",
|
||||
"rotate_secret",
|
||||
"create_queue",
|
||||
"publish_topic",
|
||||
"snapshot_database",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "vercel",
|
||||
label: "Vercel",
|
||||
operations: [
|
||||
"create_project",
|
||||
"deploy_project",
|
||||
"promote_deployment",
|
||||
"rollback_deployment",
|
||||
"add_domain",
|
||||
"remove_domain",
|
||||
"set_env_variable",
|
||||
"remove_env_variable",
|
||||
"purge_cache",
|
||||
"inspect_deployment",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "figma",
|
||||
label: "Figma",
|
||||
operations: [
|
||||
"create_file",
|
||||
"duplicate_file",
|
||||
"create_page",
|
||||
"rename_layer",
|
||||
"add_comment",
|
||||
"resolve_comment",
|
||||
"publish_library",
|
||||
"create_branch",
|
||||
"merge_branch",
|
||||
"export_frame",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "airtable",
|
||||
label: "Airtable",
|
||||
operations: [
|
||||
"create_base",
|
||||
"create_table",
|
||||
"add_field",
|
||||
"create_record",
|
||||
"update_record",
|
||||
"delete_record",
|
||||
"find_records",
|
||||
"link_records",
|
||||
"create_view",
|
||||
"sort_view",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "dropbox",
|
||||
label: "Dropbox",
|
||||
operations: [
|
||||
"upload_file",
|
||||
"download_file",
|
||||
"move_file",
|
||||
"copy_file",
|
||||
"delete_file",
|
||||
"restore_file",
|
||||
"share_link",
|
||||
"revoke_link",
|
||||
"create_folder",
|
||||
"search_files",
|
||||
],
|
||||
},
|
||||
{
|
||||
namespace: "snowflake",
|
||||
label: "Snowflake",
|
||||
operations: [
|
||||
"create_warehouse",
|
||||
"resize_warehouse",
|
||||
"suspend_warehouse",
|
||||
"resume_warehouse",
|
||||
"create_database",
|
||||
"create_schema",
|
||||
"create_table",
|
||||
"load_stage",
|
||||
"run_query",
|
||||
"grant_role",
|
||||
],
|
||||
},
|
||||
] as const
|
||||
|
||||
const Input = Schema.Struct({})
|
||||
|
||||
export const Plugin = {
|
||||
id: "opencode.tool.search-fixture",
|
||||
effect: Effect.fn("SearchFixtureTool.Plugin")(function* (ctx: PluginContext) {
|
||||
yield* ctx.tool
|
||||
.transform((draft) => {
|
||||
catalog.forEach((group) =>
|
||||
group.operations.forEach((operation) => {
|
||||
const action = operation.replaceAll("_", " ")
|
||||
draft.add(
|
||||
operation,
|
||||
Tool.make({
|
||||
description: `${action[0]?.toUpperCase()}${action.slice(1)} in ${group.label}.`,
|
||||
input: Input,
|
||||
output: Schema.String,
|
||||
execute: () => Effect.succeed(`Completed ${action}.`),
|
||||
}),
|
||||
{ group: group.namespace, deferred: true },
|
||||
)
|
||||
}),
|
||||
)
|
||||
})
|
||||
.pipe(Effect.orDie)
|
||||
}),
|
||||
}
|
||||
@@ -13,6 +13,26 @@ import { testEffect } from "./lib/effect"
|
||||
const it = testEffect(LayerNode.compile(Git.node))
|
||||
|
||||
describe("Git", () => {
|
||||
it.live("discovers repository metadata without a work tree", () =>
|
||||
Effect.gen(function* () {
|
||||
const root = yield* Effect.acquireRelease(
|
||||
Effect.promise(() => tmpdir()),
|
||||
(dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
|
||||
)
|
||||
yield* Effect.promise(async () => {
|
||||
await initRepo(root.path)
|
||||
await $`git config core.bare true`.cwd(root.path).quiet()
|
||||
})
|
||||
const directory = AbsolutePath.make(yield* Effect.promise(() => fs.realpath(root.path)))
|
||||
const git = yield* Git.Service
|
||||
const repository = yield* git.repo.discover(directory)
|
||||
|
||||
expect(repository?.worktree).toBe(directory)
|
||||
expect(repository?.gitDirectory).toBe(AbsolutePath.make(path.join(directory, ".git")))
|
||||
expect(repository?.commonDirectory).toBe(repository?.gitDirectory)
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("clones a remote and reads checkout metadata", () =>
|
||||
withRemote((fixture) =>
|
||||
Effect.gen(function* () {
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
import { expect, test } from "bun:test"
|
||||
import { CopilotModels } from "@opencode-ai/core/github-copilot/models"
|
||||
import { ModelV2 } from "@opencode-ai/core/model"
|
||||
import { ProviderV2 } from "@opencode-ai/core/provider"
|
||||
|
||||
test("defensively syncs advertised Copilot models", async () => {
|
||||
const server = Bun.serve({
|
||||
port: 0,
|
||||
fetch: () =>
|
||||
Response.json({
|
||||
data: [
|
||||
{
|
||||
model_picker_enabled: true,
|
||||
id: "gpt-5",
|
||||
name: "GPT-5 remote",
|
||||
version: "gpt-5-2026-06-01",
|
||||
supported_endpoints: ["/responses"],
|
||||
billing: {
|
||||
token_prices: {
|
||||
batch_size: 0,
|
||||
default: { input_price: 10, output_price: 20, cache_price: 5 },
|
||||
},
|
||||
},
|
||||
capabilities: {
|
||||
family: "gpt",
|
||||
limits: {
|
||||
max_context_window_tokens: 200000,
|
||||
max_output_tokens: 16384,
|
||||
max_prompt_tokens: 180000,
|
||||
},
|
||||
supports: { tool_calls: true, reasoning_effort: ["low", "high"] },
|
||||
},
|
||||
},
|
||||
{
|
||||
model_picker_enabled: false,
|
||||
id: "utility",
|
||||
name: "Utility",
|
||||
version: "utility-2026-06-01",
|
||||
capabilities: {
|
||||
family: "utility",
|
||||
limits: { max_output_tokens: 1000, max_prompt_tokens: 8000 },
|
||||
supports: { tool_calls: false },
|
||||
},
|
||||
},
|
||||
{ model_picker_enabled: true, id: "incomplete" },
|
||||
],
|
||||
}),
|
||||
})
|
||||
|
||||
try {
|
||||
const existing = ModelV2.Info.make({
|
||||
...ModelV2.Info.empty(ProviderV2.ID.githubCopilot, ModelV2.ID.make("gpt-5")),
|
||||
modelID: ModelV2.ID.make("gpt-5"),
|
||||
name: "GPT-5 local",
|
||||
})
|
||||
const stale = ModelV2.Info.make({
|
||||
...ModelV2.Info.empty(ProviderV2.ID.githubCopilot, ModelV2.ID.make("stale")),
|
||||
modelID: ModelV2.ID.make("stale"),
|
||||
})
|
||||
const models = await CopilotModels.get(server.url.origin, {}, [existing, stale])
|
||||
const model = models.get(ModelV2.ID.make("gpt-5"))
|
||||
|
||||
expect(model?.name).toBe("GPT-5 local")
|
||||
expect(model?.settings).toMatchObject({ baseURL: server.url.origin, endpoint: "responses" })
|
||||
expect(model?.cost[0]).toMatchObject({ input: 0, output: 0, cache: { read: 0, write: 0 } })
|
||||
expect(model?.variants.map((variant) => variant.id)).toEqual([
|
||||
ModelV2.VariantID.make("low"),
|
||||
ModelV2.VariantID.make("high"),
|
||||
])
|
||||
expect(models.get(ModelV2.ID.make("utility"))?.enabled).toBe(false)
|
||||
expect(models.has(ModelV2.ID.make("stale"))).toBe(false)
|
||||
expect(models.has(ModelV2.ID.make("incomplete"))).toBe(false)
|
||||
} finally {
|
||||
await server.stop(true)
|
||||
}
|
||||
})
|
||||
@@ -249,6 +249,36 @@ describe("LocationServiceMap", () => {
|
||||
),
|
||||
)
|
||||
|
||||
itWithSdk.live("does not reload plugins when config updates leave plugin operations unchanged", () =>
|
||||
Effect.acquireRelease(
|
||||
Effect.promise(() => tmpdir()),
|
||||
(dir) => Effect.promise(() => dir[Symbol.asyncDispose]()),
|
||||
).pipe(
|
||||
Effect.flatMap((dir) =>
|
||||
Effect.gen(function* () {
|
||||
const activations = { count: 0 }
|
||||
const sdk = yield* SdkPlugins.Service
|
||||
yield* sdk.register(
|
||||
EffectPlugin.define({
|
||||
id: "unchanged-config-plugin",
|
||||
effect: () => Effect.sync(() => ++activations.count).pipe(Effect.asVoid),
|
||||
}),
|
||||
)
|
||||
|
||||
const locations = yield* LocationServiceMap.Service
|
||||
const context = yield* locations.contextEffect(Location.Ref.make({ directory: AbsolutePath.make(dir.path) }))
|
||||
yield* PluginSupervisor.Service.use((supervisor) => supervisor.flush).pipe(Effect.provide(context))
|
||||
expect(activations.count).toBe(1)
|
||||
|
||||
yield* EventV2.Service.use((events) => events.publish(Config.Event.Updated, {})).pipe(Effect.provide(context))
|
||||
yield* Effect.sleep("200 millis")
|
||||
|
||||
expect(activations.count).toBe(1)
|
||||
}),
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
itWithSdk.live("keeps flush open while later hot reload runs", () =>
|
||||
Effect.acquireRelease(
|
||||
Effect.promise(() => tmpdir()),
|
||||
@@ -550,7 +580,6 @@ describe("LocationServiceMap", () => {
|
||||
expect(blockedState.providers.some((provider) => provider.id === allowedID)).toBe(false)
|
||||
expect(blockedState.tools.map((tool) => tool.name).sort()).toEqual([
|
||||
"edit",
|
||||
"execute",
|
||||
"glob",
|
||||
"grep",
|
||||
"patch",
|
||||
@@ -568,7 +597,6 @@ describe("LocationServiceMap", () => {
|
||||
expect(allowedState.providers.some((provider) => provider.id === blockedID)).toBe(false)
|
||||
expect(allowedState.tools.map((tool) => tool.name).sort()).toEqual([
|
||||
"edit",
|
||||
"execute",
|
||||
"glob",
|
||||
"grep",
|
||||
"patch",
|
||||
@@ -708,7 +736,7 @@ describe("LocationServiceMap", () => {
|
||||
})
|
||||
.pipe(Effect.asVoid),
|
||||
})
|
||||
yield* plugins.activate([reviewer])
|
||||
yield* plugins.activate([{ ...reviewer, version: "1" }])
|
||||
|
||||
expect(yield* (yield* AgentV2.Service).get(AgentV2.ID.make("reviewer"))).toMatchObject({
|
||||
description: "Reviews code",
|
||||
|
||||
@@ -18,6 +18,8 @@ const it = testEffect(PluginTestLayer)
|
||||
|
||||
class Secret extends Context.Service<Secret, string>()("@opencode/test/PluginSecret") {}
|
||||
|
||||
const versioned = <R>(plugin: EffectPlugin.Plugin<R>, version = "1") => ({ ...plugin, version })
|
||||
|
||||
describe("PluginV2", () => {
|
||||
it.live("exposes public events through the plugin context", () =>
|
||||
Effect.gen(function* () {
|
||||
@@ -37,15 +39,18 @@ describe("PluginV2", () => {
|
||||
}),
|
||||
)
|
||||
|
||||
it.effect("replaces plugins by ID", () =>
|
||||
it.effect("replaces plugins by ID and version", () =>
|
||||
Effect.gen(function* () {
|
||||
const plugins = yield* PluginV2.Service
|
||||
const agents = yield* AgentV2.Service
|
||||
const events = yield* EventV2.Service
|
||||
let description = "first"
|
||||
const updated = yield* events
|
||||
.subscribe(Plugin.Event.Updated)
|
||||
.pipe(Stream.take(2), Stream.runCollect, Effect.forkScoped({ startImmediately: true }))
|
||||
let updates = 0
|
||||
const unsubscribe = yield* events.listen((event) =>
|
||||
Effect.sync(() => {
|
||||
if (event.type === Plugin.Event.Updated.type) updates++
|
||||
}),
|
||||
)
|
||||
|
||||
const managed = () =>
|
||||
EffectPlugin.define({
|
||||
@@ -60,17 +65,23 @@ describe("PluginV2", () => {
|
||||
.pipe(Effect.asVoid),
|
||||
})
|
||||
|
||||
yield* plugins.activate([managed()])
|
||||
yield* plugins.activate([versioned(managed(), "1")])
|
||||
|
||||
expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("first")
|
||||
|
||||
description = "second"
|
||||
yield* plugins.activate([managed()])
|
||||
yield* plugins.activate([versioned(managed(), "2")])
|
||||
expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("second")
|
||||
|
||||
description = "third"
|
||||
yield* plugins.activate([versioned(managed(), "2")])
|
||||
expect(updates).toBe(2)
|
||||
expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("second")
|
||||
expect(yield* Fiber.join(updated)).toHaveLength(2)
|
||||
|
||||
yield* plugins.activate([])
|
||||
expect(yield* agents.get(AgentV2.ID.make("configured"))).toBeUndefined()
|
||||
expect(updates).toBe(3)
|
||||
yield* unsubscribe
|
||||
}),
|
||||
)
|
||||
|
||||
@@ -79,12 +90,12 @@ describe("PluginV2", () => {
|
||||
const plugins = yield* PluginV2.Service
|
||||
const active = Plugin.ID.make("active")
|
||||
const duplicate = "duplicate"
|
||||
yield* plugins.activate([{ id: active, effect: () => Effect.void }])
|
||||
yield* plugins.activate([{ id: active, version: "1", effect: () => Effect.void }])
|
||||
|
||||
const result = yield* plugins
|
||||
.activate([
|
||||
{ id: duplicate, effect: () => Effect.void },
|
||||
{ id: duplicate, effect: () => Effect.void },
|
||||
{ id: duplicate, version: "1", effect: () => Effect.void },
|
||||
{ id: duplicate, version: "1", effect: () => Effect.void },
|
||||
])
|
||||
.pipe(Effect.exit)
|
||||
|
||||
@@ -117,12 +128,12 @@ describe("PluginV2", () => {
|
||||
},
|
||||
})
|
||||
|
||||
yield* plugins.activate([good, bad])
|
||||
yield* plugins.activate([versioned(good), versioned(bad)])
|
||||
expect(yield* plugins.list()).toEqual([{ id: Plugin.ID.make("good") }])
|
||||
expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("loaded")
|
||||
|
||||
fail = false
|
||||
yield* plugins.activate([good, bad])
|
||||
yield* plugins.activate([versioned(good), versioned(bad, "2")])
|
||||
expect(yield* plugins.list()).toEqual([{ id: Plugin.ID.make("good") }, { id: Plugin.ID.make("bad") }])
|
||||
}),
|
||||
)
|
||||
@@ -155,8 +166,8 @@ describe("PluginV2", () => {
|
||||
}),
|
||||
})
|
||||
|
||||
yield* plugins.activate([previous])
|
||||
yield* plugins.activate([replacement])
|
||||
yield* plugins.activate([versioned(previous)])
|
||||
yield* plugins.activate([versioned(replacement, "2")])
|
||||
|
||||
expect(yield* plugins.list()).toEqual([{ id: Plugin.ID.make("managed") }])
|
||||
expect((yield* agents.get(AgentV2.ID.make("configured")))?.description).toBe("previous")
|
||||
@@ -187,8 +198,8 @@ describe("PluginV2", () => {
|
||||
effect: () => Effect.die(new Error("replacement failed")),
|
||||
})
|
||||
|
||||
yield* plugins.activate([previous])
|
||||
yield* plugins.activate([replacement])
|
||||
yield* plugins.activate([versioned(previous)])
|
||||
yield* plugins.activate([versioned(replacement, "2")])
|
||||
|
||||
expect(yield* plugins.list()).toEqual([])
|
||||
expect(yield* agents.get(AgentV2.ID.make("configured"))).toBeUndefined()
|
||||
@@ -202,6 +213,7 @@ describe("PluginV2", () => {
|
||||
yield* plugins.activate(
|
||||
["first", "second"].map((id) => ({
|
||||
id,
|
||||
version: "1",
|
||||
effect: () => Effect.addFinalizer(() => Effect.sync(() => closed.push(id))),
|
||||
})),
|
||||
)
|
||||
@@ -225,7 +237,7 @@ describe("PluginV2", () => {
|
||||
),
|
||||
})
|
||||
|
||||
yield* plugins.activate([plugin]).pipe(Effect.provideService(Secret, "secret"))
|
||||
yield* plugins.activate([versioned(plugin)]).pipe(Effect.provideService(Secret, "secret"))
|
||||
|
||||
expect(visible).toBe(false)
|
||||
}),
|
||||
@@ -253,7 +265,7 @@ describe("PluginV2", () => {
|
||||
.pipe(Effect.orDie),
|
||||
})
|
||||
|
||||
yield* plugins.activate([plugin])
|
||||
yield* plugins.activate([versioned(plugin)])
|
||||
expect((yield* registry.materialize()).definitions.map((tool) => tool.name)).toContain("plugin_tool")
|
||||
|
||||
yield* plugins.activate([])
|
||||
@@ -284,7 +296,7 @@ describe("PluginV2", () => {
|
||||
.pipe(Effect.orDie),
|
||||
})
|
||||
|
||||
yield* plugins.activate([plugin])
|
||||
yield* plugins.activate([versioned(plugin)])
|
||||
|
||||
expect((yield* registry.materialize()).definitions.map((tool) => tool.name)).toEqual([
|
||||
"plain",
|
||||
@@ -343,7 +355,7 @@ describe("PluginV2", () => {
|
||||
}),
|
||||
})
|
||||
|
||||
yield* plugins.activate([plugin])
|
||||
yield* plugins.activate([versioned(plugin)])
|
||||
|
||||
const materialized = yield* registry.materialize()
|
||||
const settlement = yield* materialized.settle({
|
||||
|
||||
@@ -82,6 +82,7 @@ export function host(overrides: Overrides = {}): PluginContext {
|
||||
get: () => Effect.die("unused session.get"),
|
||||
prompt: () => Effect.die("unused session.prompt"),
|
||||
command: () => Effect.die("unused session.command"),
|
||||
rename: () => Effect.die("unused session.rename"),
|
||||
interrupt: () => Effect.die("unused session.interrupt"),
|
||||
},
|
||||
}
|
||||
|
||||
@@ -4,6 +4,7 @@ import { AgentV2 } from "@opencode-ai/core/agent"
|
||||
import { PluginV2 } from "@opencode-ai/core/plugin"
|
||||
import { PluginHost } from "@opencode-ai/core/plugin/host"
|
||||
import { PluginPromise } from "@opencode-ai/core/plugin/promise"
|
||||
import { PluginRuntime } from "@opencode-ai/core/plugin/runtime"
|
||||
import { SessionV2 } from "@opencode-ai/core/session"
|
||||
import { SessionMessage } from "@opencode-ai/core/session/message"
|
||||
import { ToolRegistry } from "@opencode-ai/core/tool/registry"
|
||||
@@ -43,6 +44,37 @@ describe("fromPromise", () => {
|
||||
}),
|
||||
)
|
||||
|
||||
it.effect("forwards session rename", () =>
|
||||
Effect.gen(function* () {
|
||||
const plugin = yield* PluginV2.Service
|
||||
const runtime = yield* PluginRuntime.Service
|
||||
const renamed: { sessionID: SessionV2.ID; title: string }[] = []
|
||||
const host = yield* PluginHost.make(plugin).pipe(
|
||||
Effect.provideService(
|
||||
PluginRuntime.Service,
|
||||
PluginRuntime.Service.of({
|
||||
...runtime,
|
||||
session: {
|
||||
...runtime.session,
|
||||
rename: (input) =>
|
||||
Effect.sync(() => {
|
||||
renamed.push(input)
|
||||
}),
|
||||
},
|
||||
}),
|
||||
),
|
||||
)
|
||||
const promisePlugin = Plugin.define({
|
||||
id: "promise-session-rename",
|
||||
setup: (ctx) => ctx.session.rename({ sessionID: "ses_plugin_rename", title: "Updated scope" }),
|
||||
})
|
||||
|
||||
yield* PluginPromise.fromPromise(promisePlugin).effect(host)
|
||||
|
||||
expect(renamed).toEqual([{ sessionID: SessionV2.ID.make("ses_plugin_rename"), title: "Updated scope" }])
|
||||
}),
|
||||
)
|
||||
|
||||
it.effect("loads a promise plugin and registers a transform hook", () =>
|
||||
Effect.gen(function* () {
|
||||
const agents = yield* AgentV2.Service
|
||||
|
||||
@@ -5,8 +5,9 @@ import { Catalog } from "@opencode-ai/core/catalog"
|
||||
import { ModelV2 } from "@opencode-ai/core/model"
|
||||
import { PluginV2 } from "@opencode-ai/core/plugin"
|
||||
import { PluginHost } from "@opencode-ai/core/plugin/host"
|
||||
import { GithubCopilotPlugin } from "@opencode-ai/core/plugin/provider/github-copilot"
|
||||
import { copilotFetch, GithubCopilotPlugin } from "@opencode-ai/core/plugin/provider/github-copilot"
|
||||
import { ProviderV2 } from "@opencode-ai/core/provider"
|
||||
import { Integration } from "@opencode-ai/core/integration"
|
||||
import type { LanguageModelV3 } from "@ai-sdk/provider"
|
||||
import { testEffect } from "../lib/effect"
|
||||
import { PluginTestLayer } from "./fixture"
|
||||
@@ -39,6 +40,46 @@ function fakeSelectorSdk(calls: string[]) {
|
||||
}
|
||||
|
||||
describe("GithubCopilotPlugin", () => {
|
||||
it.effect("registers GitHub Copilot device OAuth", () =>
|
||||
Effect.gen(function* () {
|
||||
yield* addPlugin()
|
||||
expect((yield* (yield* Integration.Service).get(Integration.ID.make("github-copilot")))?.methods).toContainEqual({
|
||||
id: Integration.MethodID.make("device"),
|
||||
type: "oauth",
|
||||
label: "Login with GitHub Copilot",
|
||||
prompts: expect.any(Array),
|
||||
})
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("adds Copilot authentication and request metadata headers", () =>
|
||||
Effect.gen(function* () {
|
||||
const requests: Headers[] = []
|
||||
const send = copilotFetch(
|
||||
"token",
|
||||
async (_input: Parameters<typeof fetch>[0], init?: RequestInit) => {
|
||||
requests.push(new Headers(init?.headers))
|
||||
return Response.json({ ok: true })
|
||||
},
|
||||
false,
|
||||
)
|
||||
yield* Effect.promise(() =>
|
||||
send("https://api.githubcopilot.com/chat/completions", {
|
||||
method: "POST",
|
||||
headers: { "x-api-key": "old" },
|
||||
body: JSON.stringify({
|
||||
messages: [{ role: "user", content: [{ type: "image_url", image_url: { url: "data:image/png" } }] }],
|
||||
}),
|
||||
}),
|
||||
)
|
||||
expect(requests[0]?.get("authorization")).toBe("Bearer token")
|
||||
expect(requests[0]?.has("x-api-key")).toBe(false)
|
||||
expect(requests[0]?.get("x-initiator")).toBe("user")
|
||||
expect(requests[0]?.get("copilot-vision-request")).toBe("true")
|
||||
expect(requests[0]?.get("x-github-api-version")).toBe("2026-06-01")
|
||||
}),
|
||||
)
|
||||
|
||||
it.effect("creates the bundled Copilot SDK for the GitHub Copilot package", () =>
|
||||
Effect.gen(function* () {
|
||||
const plugin = yield* PluginV2.Service
|
||||
|
||||
@@ -54,6 +54,23 @@ function waitForSkillUpdate() {
|
||||
}
|
||||
|
||||
describe("SkillV2", () => {
|
||||
it.live("publishes updates when skill sources change", () =>
|
||||
Effect.gen(function* () {
|
||||
const skill = yield* SkillV2.Service
|
||||
|
||||
yield* Effect.acquireUseRelease(
|
||||
waitForSkillUpdate(),
|
||||
({ deferred }) =>
|
||||
skill
|
||||
.transform((editor) =>
|
||||
editor.source({ type: "directory", path: AbsolutePath.make("/tmp/opencode-skills") }),
|
||||
)
|
||||
.pipe(Effect.andThen(Deferred.await(deferred)), Effect.timeout("1 second")),
|
||||
({ fiber }) => Fiber.interrupt(fiber),
|
||||
)
|
||||
}),
|
||||
)
|
||||
|
||||
it.live("registers sources and resolves later source precedence", () =>
|
||||
Effect.acquireRelease(
|
||||
Effect.promise(() => tmpdir()),
|
||||
|
||||
@@ -1,50 +0,0 @@
|
||||
import { expect } from "bun:test"
|
||||
import { AgentV2 } from "@opencode-ai/core/agent"
|
||||
import { AppNodeBuilder } from "@opencode-ai/core/effect/app-node-builder"
|
||||
import { SessionV2 } from "@opencode-ai/core/session"
|
||||
import { SessionMessage } from "@opencode-ai/core/session/message"
|
||||
import { ToolOutputStore } from "@opencode-ai/core/tool-output-store"
|
||||
import { ToolRegistry } from "@opencode-ai/core/tool/registry"
|
||||
import { SearchFixtureTool } from "@opencode-ai/core/tool/search-fixture"
|
||||
import { Effect, Layer } from "effect"
|
||||
import { testEffect } from "./lib/effect"
|
||||
import { registerToolPlugin } from "./lib/tool"
|
||||
|
||||
const outputStore = Layer.mock(ToolOutputStore.Service, {
|
||||
bound: (input) => Effect.succeed({ output: input.output, outputPaths: [] }),
|
||||
})
|
||||
const it = testEffect(AppNodeBuilder.build(ToolRegistry.node, [[ToolOutputStore.node, outputStore]]))
|
||||
|
||||
it.effect("registers 200 searchable no-op tools across namespaces", () =>
|
||||
Effect.gen(function* () {
|
||||
expect(SearchFixtureTool.catalog).toHaveLength(20)
|
||||
expect(SearchFixtureTool.catalog.flatMap((group) => group.operations)).toHaveLength(200)
|
||||
|
||||
yield* registerToolPlugin(SearchFixtureTool.Plugin)
|
||||
const registry = yield* ToolRegistry.Service
|
||||
const tools = yield* registry.materialize()
|
||||
expect(tools.definitions.map((tool) => tool.name)).toEqual(["execute"])
|
||||
|
||||
const invoke = (code: string, id: string) =>
|
||||
tools.settle({
|
||||
sessionID: SessionV2.ID.make("ses_search_fixture"),
|
||||
agent: AgentV2.ID.make("build"),
|
||||
assistantMessageID: SessionMessage.ID.make("msg_search_fixture"),
|
||||
call: { type: "tool-call", id, name: "execute", input: { code } },
|
||||
})
|
||||
|
||||
const searched = yield* invoke(
|
||||
'return await tools.$codemode.search({ query: "refund payment", namespace: "stripe" })',
|
||||
"call_search_fixture",
|
||||
)
|
||||
expect(searched.result.type).toBe("text")
|
||||
if (searched.result.type !== "text") return
|
||||
expect(JSON.parse(String(searched.result.value)).items[0]).toMatchObject({
|
||||
path: "tools.stripe.refund_payment",
|
||||
description: "Refund payment in Stripe.",
|
||||
})
|
||||
|
||||
const completed = yield* invoke("return await tools.stripe.refund_payment({})", "call_run_fixture")
|
||||
expect(completed.result).toEqual({ type: "text", value: "Completed refund payment." })
|
||||
}),
|
||||
)
|
||||
Vendored
+1
-1
@@ -177,7 +177,7 @@ and plugin options.
|
||||
| `ctx.integration` | `list`, `get`, `connect`, `attempt`, `transform`, `reload`, and connection lookup/resolution |
|
||||
| `ctx.plugin` | `list` currently active plugin IDs |
|
||||
| `ctx.reference` | `list`, `transform`, `reload` |
|
||||
| `ctx.session` | `create`, `get`, `prompt`, `command`, `interrupt`, and `hook` |
|
||||
| `ctx.session` | `create`, `get`, `prompt`, `command`, `rename`, `interrupt`, and `hook` |
|
||||
| `ctx.skill` | `list`, `transform`, `reload` |
|
||||
| `ctx.tool` | `transform` and `hook` |
|
||||
| `ctx.aisdk` | `hook` |
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
import type { SessionApi } from "@opencode-ai/client/effect/api"
|
||||
|
||||
export type SessionDomain = Pick<SessionApi<unknown>, "create" | "get" | "prompt" | "command" | "interrupt">
|
||||
export type SessionDomain = Pick<SessionApi<unknown>, "create" | "get" | "prompt" | "command" | "rename" | "interrupt">
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
import type { SessionApi } from "@opencode-ai/client/promise/api"
|
||||
|
||||
export type SessionDomain = Pick<SessionApi, "create" | "get" | "prompt" | "command" | "interrupt">
|
||||
export type SessionDomain = Pick<SessionApi, "create" | "get" | "prompt" | "command" | "rename" | "interrupt">
|
||||
|
||||
@@ -177,6 +177,7 @@ export function Prompt(props: PromptProps) {
|
||||
const keymap = useOpencodeKeymap()
|
||||
const agentShortcut = useCommandShortcut("agent.cycle")
|
||||
const paletteShortcut = useCommandShortcut("command.palette.show")
|
||||
const liveWorkShortcut = useCommandShortcut("session.child.first")
|
||||
const renderer = useRenderer()
|
||||
const exit = useExit()
|
||||
const dimensions = useTerminalDimensions()
|
||||
@@ -290,7 +291,7 @@ export function Prompt(props: PromptProps) {
|
||||
.list(session.location)
|
||||
?.find((model) => model.providerID === last.model.providerID && model.id === last.model.id)
|
||||
const pct = model?.limit.context ? `${Math.round((tokens / model.limit.context) * 100)}%` : undefined
|
||||
const cost = session.cost
|
||||
const cost = data.session.cost(props.sessionID)
|
||||
return {
|
||||
context: pct ? `${Locale.number(tokens)} (${pct})` : Locale.number(tokens),
|
||||
cost: cost > 0 ? money.format(cost) : undefined,
|
||||
@@ -864,6 +865,7 @@ export function Prompt(props: PromptProps) {
|
||||
|
||||
useBindings(() => {
|
||||
return {
|
||||
priority: 1,
|
||||
target: inputTarget,
|
||||
enabled: (() => {
|
||||
cursorVersion()
|
||||
@@ -876,8 +878,12 @@ export function Prompt(props: PromptProps) {
|
||||
category: "Prompt",
|
||||
run() {
|
||||
if (input.cursorOffset !== 0) {
|
||||
if (input.scrollY + input.visualCursor.visualRow === 0) input.cursorOffset = 0
|
||||
return false
|
||||
if (input.scrollY + input.visualCursor.visualRow === 0) {
|
||||
input.cursorOffset = 0
|
||||
return
|
||||
}
|
||||
input.moveCursorUp()
|
||||
return
|
||||
}
|
||||
|
||||
const item = history.move(-1, input.plainText)
|
||||
@@ -896,6 +902,7 @@ export function Prompt(props: PromptProps) {
|
||||
|
||||
useBindings(() => {
|
||||
return {
|
||||
priority: 1,
|
||||
target: inputTarget,
|
||||
enabled: (() => {
|
||||
cursorVersion()
|
||||
@@ -911,9 +918,12 @@ export function Prompt(props: PromptProps) {
|
||||
if (
|
||||
input.scrollY + input.visualCursor.visualRow ===
|
||||
Math.max(0, input.editorView.getTotalVirtualLineCount() - 1)
|
||||
)
|
||||
) {
|
||||
input.cursorOffset = input.plainText.length
|
||||
return false
|
||||
return
|
||||
}
|
||||
input.moveCursorDown()
|
||||
return
|
||||
}
|
||||
|
||||
const item = history.move(1, input.plainText)
|
||||
@@ -1608,6 +1618,9 @@ export function Prompt(props: PromptProps) {
|
||||
<Switch>
|
||||
<Match when={liveWorkStatusVisible() || statusItems().length > 0}>
|
||||
<text fg={theme.textMuted} wrapMode="none">
|
||||
<Show when={liveWorkStatusVisible() && liveWorkShortcut()}>
|
||||
{(shortcut) => <span style={{ fg: theme.text }}>{shortcut()} </span>}
|
||||
</Show>
|
||||
<Show when={subagentStatusLabel()}>
|
||||
{(label) => <span style={{ fg: theme.textMuted }}>{label()}</span>}
|
||||
</Show>
|
||||
|
||||
@@ -100,7 +100,7 @@ export const Definitions = {
|
||||
session_toggle_timestamps: keybind("none", "Toggle message timestamps"),
|
||||
session_toggle_generic_tool_output: keybind("none", "Toggle generic tool output"),
|
||||
session_queued_prompts: keybind("<leader>q", "Manage queued prompts"),
|
||||
session_child_first: keybind("<leader>down", "Toggle subagent picker"),
|
||||
session_child_first: keybind("down,<leader>down", "Toggle subagent picker"),
|
||||
session_child_cycle: keybind("right", "Go to next child session"),
|
||||
session_child_cycle_reverse: keybind("left", "Go to previous child session"),
|
||||
session_parent: keybind("up", "Go to parent session"),
|
||||
|
||||
@@ -805,6 +805,15 @@ export const { use: useData, provider: DataProvider } = createSimpleContext({
|
||||
family(sessionID: string) {
|
||||
return store.session.family[resolveRoot(sessionID)] ?? []
|
||||
},
|
||||
cost(sessionID: string) {
|
||||
const session = store.session.info[sessionID]
|
||||
if (!session) return 0
|
||||
if (session.parentID) return session.cost
|
||||
return (store.session.family[sessionID] ?? [sessionID]).reduce(
|
||||
(total, id) => total + (store.session.info[id]?.cost ?? 0),
|
||||
0,
|
||||
)
|
||||
},
|
||||
status(sessionID: string) {
|
||||
return store.session.status[sessionID] ?? "idle"
|
||||
},
|
||||
|
||||
@@ -16,7 +16,7 @@ function View(props: { api: TuiPluginApi; session_id: string }) {
|
||||
const theme = () => props.api.theme.current
|
||||
const msg = createMemo(() => data.session.message.list(props.session_id))
|
||||
const session = createMemo(() => data.session.get(props.session_id))
|
||||
const cost = createMemo(() => session()?.cost ?? 0)
|
||||
const cost = createMemo(() => data.session.cost(props.session_id))
|
||||
|
||||
const state = createMemo(() => {
|
||||
const last = lastAssistantWithUsage(msg(), session()?.revert?.messageID)
|
||||
|
||||
@@ -193,6 +193,10 @@ function formatOptions(config: FormatConfig) {
|
||||
[LEADER_TOKEN]: leaderDisplay(config),
|
||||
},
|
||||
keyNameAliases: {
|
||||
up: "↑",
|
||||
down: "↓",
|
||||
left: "←",
|
||||
right: "→",
|
||||
pageup: "pgup",
|
||||
pagedown: "pgdn",
|
||||
delete: "del",
|
||||
|
||||
@@ -82,16 +82,11 @@ export const { use: usePromptHistory, provider: PromptHistoryProvider } = create
|
||||
const current = store.history.at(store.index)
|
||||
if (!current) return undefined
|
||||
if (current.text !== input && input.length) return
|
||||
setStore(
|
||||
produce((draft) => {
|
||||
const next = store.index + direction
|
||||
if (Math.abs(next) > store.history.length) return
|
||||
if (next > 0) return
|
||||
draft.index = next
|
||||
}),
|
||||
)
|
||||
if (store.index === 0) return emptyPrompt()
|
||||
return store.history.at(store.index)
|
||||
const next = store.index + direction
|
||||
if (Math.abs(next) > store.history.length || next > 0) return
|
||||
setStore("index", next)
|
||||
if (next === 0) return emptyPrompt()
|
||||
return store.history.at(next)
|
||||
},
|
||||
append(item: PromptInfo) {
|
||||
const entry = structuredClone(unwrap(item))
|
||||
|
||||
@@ -3,7 +3,7 @@ import { createStore } from "solid-js/store"
|
||||
import { TextAttributes } from "@opentui/core"
|
||||
import { useTheme } from "../../../context/theme"
|
||||
import { SplitBorder } from "../../../ui/border"
|
||||
import { useBindings, useOpencodeModeStack, useCommandShortcut } from "../../../keymap"
|
||||
import { useBindings, useOpencodeModeStack } from "../../../keymap"
|
||||
import { SubagentsTab } from "./subagents-tab"
|
||||
import { ShellTab } from "./shell-tab"
|
||||
|
||||
@@ -105,8 +105,6 @@ export function Composer(props: ComposerProps) {
|
||||
],
|
||||
}))
|
||||
|
||||
const closeHint = useCommandShortcut("session.child_first")
|
||||
|
||||
return (
|
||||
<ComposerContext.Provider value={ctx}>
|
||||
<box flexShrink={0} visible={props.open}>
|
||||
@@ -121,32 +119,35 @@ export function Composer(props: ComposerProps) {
|
||||
paddingBottom={1}
|
||||
>
|
||||
<box gap={1}>
|
||||
<Show
|
||||
when={tabList().length > 1}
|
||||
fallback={
|
||||
<box flexDirection="row" paddingLeft={1}>
|
||||
<box flexDirection="row" justifyContent="space-between" paddingLeft={1}>
|
||||
<Show
|
||||
when={tabList().length > 1}
|
||||
fallback={
|
||||
<text fg={theme.text} attributes={TextAttributes.BOLD}>
|
||||
{tabList()[0]?.label ?? ""}
|
||||
</text>
|
||||
}
|
||||
>
|
||||
<box flexDirection="row" gap={2}>
|
||||
<For each={tabList()}>
|
||||
{(t) => {
|
||||
const isActive = createMemo(() => store.active === t.id)
|
||||
return (
|
||||
<text
|
||||
fg={isActive() ? theme.text : theme.textMuted}
|
||||
attributes={isActive() ? TextAttributes.BOLD : undefined}
|
||||
>
|
||||
{t.label}
|
||||
</text>
|
||||
)
|
||||
}}
|
||||
</For>
|
||||
</box>
|
||||
}
|
||||
>
|
||||
<box flexDirection="row" gap={2} paddingLeft={1}>
|
||||
<For each={tabList()}>
|
||||
{(t) => {
|
||||
const isActive = createMemo(() => store.active === t.id)
|
||||
return (
|
||||
<text
|
||||
fg={isActive() ? theme.text : theme.textMuted}
|
||||
attributes={isActive() ? TextAttributes.BOLD : undefined}
|
||||
>
|
||||
{t.label}
|
||||
</text>
|
||||
)
|
||||
}}
|
||||
</For>
|
||||
</box>
|
||||
</Show>
|
||||
</Show>
|
||||
<text fg={theme.textMuted} onMouseUp={close}>
|
||||
esc
|
||||
</text>
|
||||
</box>
|
||||
<SubagentsTab sessionID={props.sessionID} />
|
||||
<ShellTab sessionID={props.sessionID} />
|
||||
<box flexDirection="row" gap={2} paddingLeft={1} flexShrink={0}>
|
||||
@@ -168,12 +169,6 @@ export function Composer(props: ComposerProps) {
|
||||
<span style={{ fg: theme.textMuted }}>←/→</span>
|
||||
</text>
|
||||
</Show>
|
||||
<text>
|
||||
<span style={{ fg: theme.text }}>
|
||||
<b>close</b>{" "}
|
||||
</span>
|
||||
<span style={{ fg: theme.textMuted }}>{closeHint()}</span>
|
||||
</text>
|
||||
</box>
|
||||
</box>
|
||||
</box>
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import { createMemo, createSignal, onMount, Show } from "solid-js"
|
||||
import { unwrap } from "solid-js/store"
|
||||
import { useData } from "../../context/data"
|
||||
import { useRoute } from "../../context/route"
|
||||
import { useSDK } from "../../context/sdk"
|
||||
@@ -38,7 +39,7 @@ export function DialogFork(props: { sessionID: string; messageID?: string; onMov
|
||||
description: file.description,
|
||||
mention: file.mention,
|
||||
})),
|
||||
agents: structuredClone(message.agents ?? []),
|
||||
agents: structuredClone(unwrap(message.agents ?? [])),
|
||||
pasted: [],
|
||||
}
|
||||
: undefined,
|
||||
|
||||
@@ -33,7 +33,7 @@ export function SubagentFooter() {
|
||||
.model.list(current.location)
|
||||
?.find((model) => model.providerID === last.model.providerID && model.id === last.model.id)
|
||||
const pct = model?.limit.context ? `${Math.round((tokens / model.limit.context) * 100)}%` : undefined
|
||||
const cost = current.cost
|
||||
const cost = data.session.cost(route.sessionID)
|
||||
|
||||
const money = new Intl.NumberFormat("en-US", {
|
||||
style: "currency",
|
||||
|
||||
@@ -2148,12 +2148,12 @@ test("projects live instruction updates with their message ID", async () => {
|
||||
}
|
||||
})
|
||||
|
||||
function sessionInfo(id: string, parentID: string | undefined) {
|
||||
function sessionInfo(id: string, parentID: string | undefined, cost = 0) {
|
||||
return {
|
||||
id,
|
||||
parentID,
|
||||
projectID: "proj_test",
|
||||
cost: 0,
|
||||
cost,
|
||||
tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } },
|
||||
time: { created: 0, updated: 0 },
|
||||
title: id,
|
||||
@@ -2164,10 +2164,11 @@ function sessionInfo(id: string, parentID: string | undefined) {
|
||||
// Mounts a DataProvider whose `/api/session/:id` responses are driven by the
|
||||
// given parent map (sessionID -> parentID). Roots omit the entry. Reused across
|
||||
// the family-index tests below.
|
||||
async function mountData(parents: Record<string, string>) {
|
||||
async function mountData(parents: Record<string, string>, costs: Record<string, number> = {}) {
|
||||
const calls = createFetch((url) => {
|
||||
const match = url.pathname.match(/^\/api\/session\/([^/]+)$/)
|
||||
if (match && match[1] !== "active") return json({ data: sessionInfo(match[1], parents[match[1]]) })
|
||||
if (match && match[1] !== "active")
|
||||
return json({ data: sessionInfo(match[1], parents[match[1]], costs[match[1]]) })
|
||||
})
|
||||
let data!: ReturnType<typeof useData>
|
||||
let ready!: () => void
|
||||
@@ -2235,6 +2236,24 @@ test("indexes arbitrarily deep nesting under a single root", async () => {
|
||||
}
|
||||
})
|
||||
|
||||
test("totals family cost for roots and keeps subagent cost scoped", async () => {
|
||||
const { data, app } = await mountData(
|
||||
{ grandchild: "child", child: "root" },
|
||||
{ root: 1, child: 2, grandchild: 3 },
|
||||
)
|
||||
try {
|
||||
await data.session.refresh("grandchild")
|
||||
await data.session.refresh("child")
|
||||
await data.session.refresh("root")
|
||||
|
||||
expect(data.session.cost("root")).toBe(6)
|
||||
expect(data.session.cost("child")).toBe(2)
|
||||
expect(data.session.cost("grandchild")).toBe(3)
|
||||
} finally {
|
||||
app.renderer.destroy()
|
||||
}
|
||||
})
|
||||
|
||||
test("re-registering an existing session is idempotent", async () => {
|
||||
const { data, app } = await mountData({ grandchild: "child", child: "root" })
|
||||
try {
|
||||
|
||||
@@ -86,6 +86,12 @@ test("resolves a session move keybind", () => {
|
||||
expect(config.keybinds.get("session.move")).toMatchObject([{ key: "ctrl+o" }])
|
||||
})
|
||||
|
||||
test("opens the subagent picker with down", () => {
|
||||
const config = resolve({}, { terminalSuspend: true })
|
||||
|
||||
expect(config.keybinds.get("session.child.first")).toMatchObject([{ key: "down,<leader>down" }])
|
||||
})
|
||||
|
||||
test("disables suspend and assigns ctrl+z to undo when unsupported", () => {
|
||||
const config = resolve({}, { terminalSuspend: false })
|
||||
|
||||
|
||||
@@ -5,7 +5,13 @@ import { testRender, useRenderer } from "@opentui/solid"
|
||||
import { expect, test } from "bun:test"
|
||||
import { onCleanup } from "solid-js"
|
||||
import { TuiKeybind } from "../src/config/keybind"
|
||||
import { getOpencodeModeStack, OPENCODE_BASE_MODE, OpencodeKeymapProvider, registerOpencodeKeymap } from "../src/keymap"
|
||||
import {
|
||||
formatKeySequence,
|
||||
getOpencodeModeStack,
|
||||
OPENCODE_BASE_MODE,
|
||||
OpencodeKeymapProvider,
|
||||
registerOpencodeKeymap,
|
||||
} from "../src/keymap"
|
||||
|
||||
function createResolvedKeymapConfig(input: TuiKeybind.KeybindOverrides = {}) {
|
||||
const keybinds = TuiKeybind.parse(input)
|
||||
@@ -63,6 +69,47 @@ test("legacy page key aliases compile as page keys", async () => {
|
||||
}
|
||||
})
|
||||
|
||||
test("formats navigation keys as arrows", async () => {
|
||||
const shortcuts: Record<string, string> = {}
|
||||
|
||||
function Harness() {
|
||||
const renderer = useRenderer()
|
||||
const keymap = createDefaultOpenTuiKeymap(renderer)
|
||||
const config = createResolvedKeymapConfig()
|
||||
const offKeymap = registerOpencodeKeymap(keymap, renderer, config)
|
||||
const commands = ["session.parent", "session.child.first", "session.child.previous", "session.child.next"]
|
||||
const offLayer = keymap.registerLayer({
|
||||
bindings: config.keybinds.gather("test.arrows", commands),
|
||||
})
|
||||
const bindings = keymap.getCommandBindings({ visibility: "registered", commands })
|
||||
commands.forEach((command) => {
|
||||
shortcuts[command] = formatKeySequence(bindings.get(command)?.[0]?.sequence, config)
|
||||
})
|
||||
onCleanup(() => {
|
||||
offLayer()
|
||||
offKeymap()
|
||||
})
|
||||
|
||||
return (
|
||||
<OpencodeKeymapProvider keymap={keymap}>
|
||||
<box />
|
||||
</OpencodeKeymapProvider>
|
||||
)
|
||||
}
|
||||
|
||||
const app = await testRender(() => <Harness />)
|
||||
try {
|
||||
expect(shortcuts).toEqual({
|
||||
"session.parent": "↑",
|
||||
"session.child.first": "↓",
|
||||
"session.child.previous": "←",
|
||||
"session.child.next": "→",
|
||||
})
|
||||
} finally {
|
||||
app.renderer.destroy()
|
||||
}
|
||||
})
|
||||
|
||||
test("mode-less bindings stay active when opencode mode changes", async () => {
|
||||
const counts: Record<string, Record<string, number>> = {}
|
||||
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
/** @jsxImportSource @opentui/solid */
|
||||
import { testRender } from "@opentui/solid"
|
||||
import { expect, test } from "bun:test"
|
||||
import { mkdir } from "node:fs/promises"
|
||||
import path from "node:path"
|
||||
import { TuiPathsProvider } from "../../src/context/runtime"
|
||||
import { PromptHistoryProvider, usePromptHistory } from "../../src/prompt/history"
|
||||
import { tmpdir } from "../fixture/fixture"
|
||||
|
||||
test("down rejects at the newest history item with an empty prompt", async () => {
|
||||
await using tmp = await tmpdir()
|
||||
const state = path.join(tmp.path, "state")
|
||||
await mkdir(state, { recursive: true })
|
||||
let history: ReturnType<typeof usePromptHistory>
|
||||
|
||||
function Consumer() {
|
||||
history = usePromptHistory()
|
||||
return <box />
|
||||
}
|
||||
|
||||
const app = await testRender(() => (
|
||||
<TuiPathsProvider value={{ cwd: tmp.path, home: tmp.path, state, worktree: tmp.path }}>
|
||||
<PromptHistoryProvider>
|
||||
<Consumer />
|
||||
</PromptHistoryProvider>
|
||||
</TuiPathsProvider>
|
||||
))
|
||||
try {
|
||||
await app.renderOnce()
|
||||
history!.append({ text: "previous", files: [], agents: [], pasted: [] })
|
||||
|
||||
expect(history!.move(1, "")).toBeUndefined()
|
||||
expect(history!.move(-1, "")?.text).toBe("previous")
|
||||
expect(history!.move(1, "previous")?.text).toBe("")
|
||||
} finally {
|
||||
app.renderer.destroy()
|
||||
}
|
||||
})
|
||||
Reference in New Issue
Block a user