@microsoft/copilot-sdk 0.0.0-stage → 2.0.0-preview.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2531 -2
- package/dist/canvas.d.ts +135 -0
- package/dist/canvas.js +51 -0
- package/dist/cjs/canvas.js +77 -0
- package/dist/cjs/cliVersion.js +31 -0
- package/dist/cjs/client.js +3941 -0
- package/dist/cjs/copilotRequestHandler.js +815 -0
- package/dist/cjs/decisions.js +139 -0
- package/dist/cjs/entra.js +83 -0
- package/dist/cjs/extension.js +79 -0
- package/dist/cjs/ffiRuntimeHost.js +400 -0
- package/dist/cjs/generated/lifecycle-diagnostics.js +16 -0
- package/dist/cjs/generated/rpc.js +5883 -0
- package/dist/cjs/generated/session-events.js +16 -0
- package/dist/cjs/host.js +83 -0
- package/dist/cjs/index.js +100 -0
- package/dist/cjs/installationConfirmation.js +98 -0
- package/dist/cjs/jsonrpcTypes.js +41 -0
- package/dist/cjs/localModelJson.js +103 -0
- package/dist/cjs/package.json +1 -0
- package/dist/cjs/providerConfiguration.js +39 -0
- package/dist/cjs/rpcCancellation.js +49 -0
- package/dist/cjs/runtimeArtifacts.js +255 -0
- package/dist/cjs/schema.js +40 -0
- package/dist/cjs/sdkProtocolVersion.js +33 -0
- package/dist/cjs/session.js +2764 -0
- package/dist/cjs/sessionFsProvider.js +283 -0
- package/dist/cjs/taskAnalyticsJson.js +47 -0
- package/dist/cjs/telemetry.js +35 -0
- package/dist/cjs/toolSet.js +107 -0
- package/dist/cjs/types.js +204 -0
- package/dist/cjs/workflow.js +278 -0
- package/dist/cliVersion.d.ts +2 -0
- package/dist/cliVersion.js +6 -0
- package/dist/client.d.ts +576 -0
- package/dist/client.js +3924 -0
- package/dist/copilotRequestHandler.d.ts +91 -0
- package/dist/copilotRequestHandler.js +787 -0
- package/dist/decisions.d.ts +65 -0
- package/dist/decisions.js +113 -0
- package/dist/entra.d.ts +3 -0
- package/dist/entra.js +59 -0
- package/dist/extension.d.ts +69 -0
- package/dist/extension.js +59 -0
- package/dist/ffiRuntimeHost.d.ts +44 -0
- package/dist/ffiRuntimeHost.js +366 -0
- package/dist/generated/lifecycle-diagnostics.d.ts +232 -0
- package/dist/generated/lifecycle-diagnostics.js +0 -0
- package/dist/generated/rpc.d.ts +47706 -0
- package/dist/generated/rpc.js +5854 -0
- package/dist/generated/session-events.d.ts +17349 -0
- package/dist/generated/session-events.js +0 -0
- package/dist/host.d.ts +143 -0
- package/dist/host.js +59 -0
- package/dist/index.d.ts +23 -0
- package/dist/index.js +74 -0
- package/dist/installationConfirmation.d.ts +19 -0
- package/dist/installationConfirmation.js +74 -0
- package/dist/jsonrpcTypes.d.ts +16 -0
- package/dist/jsonrpcTypes.js +17 -0
- package/dist/localModelJson.d.ts +1 -0
- package/dist/localModelJson.js +69 -0
- package/dist/providerConfiguration.d.ts +3 -0
- package/dist/providerConfiguration.js +15 -0
- package/dist/rpcCancellation.d.ts +3 -0
- package/dist/rpcCancellation.js +25 -0
- package/dist/runtimeArtifacts.d.ts +18 -0
- package/dist/runtimeArtifacts.js +233 -0
- package/dist/schema.d.ts +4 -0
- package/dist/schema.js +14 -0
- package/dist/sdkProtocolVersion.d.ts +10 -0
- package/dist/sdkProtocolVersion.js +8 -0
- package/dist/session.d.ts +524 -0
- package/dist/session.js +2751 -0
- package/dist/sessionFsProvider.d.ts +130 -0
- package/dist/sessionFsProvider.js +257 -0
- package/dist/taskAnalyticsJson.d.ts +8 -0
- package/dist/taskAnalyticsJson.js +12 -0
- package/dist/telemetry.d.ts +14 -0
- package/dist/telemetry.js +11 -0
- package/dist/toolSet.d.ts +75 -0
- package/dist/toolSet.js +82 -0
- package/dist/types.d.ts +3864 -0
- package/dist/types.js +169 -0
- package/dist/workflow.d.ts +413 -0
- package/dist/workflow.js +248 -0
- package/docs/agent-author.md +372 -0
- package/docs/examples.md +747 -0
- package/docs/extensions.md +121 -0
- package/docs/workflows.md +303 -0
- package/package.json +135 -5
|
@@ -0,0 +1,121 @@
|
|
|
1
|
+
# Copilot CLI Extensions
|
|
2
|
+
|
|
3
|
+
Extensions add custom tools, hooks, and behaviors to the Copilot CLI. They run as separate Node.js processes that communicate with the CLI over JSON-RPC via stdio.
|
|
4
|
+
|
|
5
|
+
## How Extensions Work
|
|
6
|
+
|
|
7
|
+
```
|
|
8
|
+
┌─────────────────────┐ JSON-RPC / stdio ┌──────────────────────┐
|
|
9
|
+
│ Copilot CLI │ ◄──────────────────────────────────► │ Extension Process │
|
|
10
|
+
│ (parent process) │ tool calls, events, hooks │ (forked child) │
|
|
11
|
+
│ │ │ │
|
|
12
|
+
│ • Discovers exts │ │ • Registers tools │
|
|
13
|
+
│ • Forks processes │ │ • Registers hooks │
|
|
14
|
+
│ • Routes tool calls │ │ • Listens to events │
|
|
15
|
+
│ • Manages lifecycle │ │ • Uses SDK APIs │
|
|
16
|
+
└─────────────────────┘ └──────────────────────┘
|
|
17
|
+
```
|
|
18
|
+
|
|
19
|
+
1. **Discovery**: The CLI scans `.github/extensions/` (project) and the user's copilot config extensions directory for subdirectories containing an `extension.mjs`, `extension.cjs` or `extension.js` entry file.
|
|
20
|
+
2. **Launch**: Legacy extensions start eagerly. Extensions with a valid opt-in `extension.json` advertise native tools/canvases without starting, and launch on first admitted demand. Each launched extension is a child process with `@microsoft/copilot-sdk` available via an automatic module resolver.
|
|
21
|
+
3. **Connection**: The extension calls `joinSession()` which establishes a JSON-RPC connection over stdio to the CLI and attaches to the user's current foreground session.
|
|
22
|
+
4. **Registration**: Tools and hooks declared in the session options are registered with the CLI and become available to the agent.
|
|
23
|
+
5. **Lifecycle**: Extensions reload on `/clear` or foreground-session replacement and stop on CLI exit. On macOS and Linux, ordinary stop/reload sends SIGTERM, then SIGKILL after 5s if still running. CLI exit and session/service teardown use a shared 1s grace period, including disabling extensions on SDK resume; Windows kills immediately without a grace period.
|
|
24
|
+
|
|
25
|
+
## File Structure
|
|
26
|
+
|
|
27
|
+
```
|
|
28
|
+
.github/extensions/
|
|
29
|
+
my-extension/
|
|
30
|
+
extension.mjs ← Entry point (required)
|
|
31
|
+
```
|
|
32
|
+
|
|
33
|
+
- The entry file must be named `extension.mjs`, `extension.cjs` or `extension.js`. If a directory holds more than one, the first in that order is used.
|
|
34
|
+
- `.mjs` (ES modules) is the recommended form and is what the scaffold generates. `.cjs` is CommonJS, and `.js` is loaded under Node's usual module-type rules. TypeScript (`.ts`) is not supported.
|
|
35
|
+
- Each extension lives in its own subdirectory.
|
|
36
|
+
- The `@microsoft/copilot-sdk` import is resolved automatically — you don't install it.
|
|
37
|
+
|
|
38
|
+
In Protected Mode, local sessions that opt into extensions add filesystem access for the
|
|
39
|
+
configured user extensions directory, validated project `.github/extensions/`, and their own
|
|
40
|
+
session's `extensions/` directory. Agent file tools and newly launched shell
|
|
41
|
+
commands use these additions; extension provider processes do not.
|
|
42
|
+
|
|
43
|
+
These are additive permissions, not visibility restrictions. Independent workspace
|
|
44
|
+
or user grants remain effective. Loading and management modes control extension
|
|
45
|
+
capabilities, not source-file confidentiality. Managed policy still applies, and an automatic scope grant is withheld
|
|
46
|
+
if its subtree overlaps an explicit read-only or denied path, including absent
|
|
47
|
+
descendants and future glob matches.
|
|
48
|
+
|
|
49
|
+
Redirected scope children do not add permissions to their link targets. Scaffold
|
|
50
|
+
and workflow source writes check the effective filesystem policy and use pinned,
|
|
51
|
+
no-follow directory handles so directory replacement cannot redirect a write.
|
|
52
|
+
|
|
53
|
+
## Opting Into Request-Driven Activation
|
|
54
|
+
|
|
55
|
+
Place a version 1 `extension.json` beside `extension.mjs`, with
|
|
56
|
+
`"initialization": "module"` and nonempty `tools` and/or `canvases` arrays using
|
|
57
|
+
the existing native-tool/canvas wire definitions. Import those same declarations
|
|
58
|
+
in the entrypoint and add handlers so the advertised schemas cannot drift.
|
|
59
|
+
Omit absent optional fields rather than writing null. Missing metadata preserves
|
|
60
|
+
eager startup; invalid metadata also produces a diagnostic.
|
|
61
|
+
|
|
62
|
+
Only native-tool and canvas entry demand is supported. Background event observers,
|
|
63
|
+
hooks, MCP-only entrypoints, commands, workflows, skills, agents, and system-message
|
|
64
|
+
changes must not depend on this activation mechanism. Postactivation MCP
|
|
65
|
+
registration continues to work normally.
|
|
66
|
+
|
|
67
|
+
Finish `joinSession()` and required listener setup before awaited module import
|
|
68
|
+
completes. The bootstrap explicitly signals that boundary; the first operation and
|
|
69
|
+
its tool-start event wait for it. Consent-aware join waits are preserved, followed
|
|
70
|
+
by a bounded module-completion wait. Missing or mismatched actual registrations
|
|
71
|
+
reject the first call and withdraw the stale advertisement; failed operations are
|
|
72
|
+
never automatically replayed.
|
|
73
|
+
|
|
74
|
+
The sidecar is limited to 256 KiB. Unknown fields or unsupported versions also
|
|
75
|
+
produce diagnostics and preserve eager startup.
|
|
76
|
+
|
|
77
|
+
## The SDK
|
|
78
|
+
|
|
79
|
+
Extensions use `@microsoft/copilot-sdk` for all interactions with the CLI:
|
|
80
|
+
|
|
81
|
+
```js
|
|
82
|
+
import { joinSession } from "@microsoft/copilot-sdk/extension";
|
|
83
|
+
|
|
84
|
+
const session = await joinSession({
|
|
85
|
+
tools: [
|
|
86
|
+
/* ... */
|
|
87
|
+
],
|
|
88
|
+
hooks: {
|
|
89
|
+
/* ... */
|
|
90
|
+
},
|
|
91
|
+
});
|
|
92
|
+
```
|
|
93
|
+
|
|
94
|
+
The `session` object provides methods for sending messages, logging to the timeline, listening to events, and accessing the RPC API. See the `.d.ts` files in the SDK package for full type information.
|
|
95
|
+
|
|
96
|
+
## Requesting Sensitive Environment Variables
|
|
97
|
+
|
|
98
|
+
The CLI strips sensitive environment variables (for example `GITHUB_TOKEN`) from every extension process before it starts. An extension that needs one asks for it by name:
|
|
99
|
+
|
|
100
|
+
```js
|
|
101
|
+
import { joinSession } from "@microsoft/copilot-sdk/extension";
|
|
102
|
+
|
|
103
|
+
const session = await joinSession({
|
|
104
|
+
requestedEnvironmentVariables: ["GITHUB_TOKEN"],
|
|
105
|
+
});
|
|
106
|
+
|
|
107
|
+
// Granted values are in process.env once joinSession resolves.
|
|
108
|
+
const token = process.env.GITHUB_TOKEN;
|
|
109
|
+
```
|
|
110
|
+
|
|
111
|
+
The CLI prompts the user with the extension's name and the exact list of variables requested. If the user approves, only those variables reach this extension and their values are written into `process.env` before `joinSession()` resolves. If the user denies, `joinSession()` rejects, the extension does not load, and its tools never reach the model.
|
|
112
|
+
|
|
113
|
+
An approval is remembered against the exact set of names the user saw, so an extension that later asks for an additional variable prompts again. Names that are unset, or that the CLI does not filter from extensions, are not prompted for.
|
|
114
|
+
|
|
115
|
+
An approved extension can pass a granted value to anything it starts, so ask only for what the extension genuinely needs.
|
|
116
|
+
|
|
117
|
+
## Further Reading
|
|
118
|
+
|
|
119
|
+
- `examples.md` — Practical code examples for tools, hooks, events, and complete extensions
|
|
120
|
+
- `workflows.md` — Authoring, running, resuming, and observing Dynamic Workflows
|
|
121
|
+
- `agent-author.md` — Step-by-step workflow for agents authoring extensions programmatically
|
|
@@ -0,0 +1,303 @@
|
|
|
1
|
+
# Dynamic Workflows
|
|
2
|
+
|
|
3
|
+
Dynamic Workflows are extension-authored, session-scoped workflows that coordinate subagents and durable steps. The API is experimental.
|
|
4
|
+
|
|
5
|
+
## Define and register a workflow
|
|
6
|
+
|
|
7
|
+
Use `defineWorkflow` and pass the returned handle to `joinSession`:
|
|
8
|
+
|
|
9
|
+
```js
|
|
10
|
+
import { defineWorkflow, joinSession } from "@microsoft/copilot-sdk/extension";
|
|
11
|
+
|
|
12
|
+
const reviewChanged = defineWorkflow({
|
|
13
|
+
meta: {
|
|
14
|
+
name: "review-changed",
|
|
15
|
+
description:
|
|
16
|
+
"Review changed files and verify the findings. " +
|
|
17
|
+
"args: { files: string[] } — the paths to review.",
|
|
18
|
+
phases: [{ title: "Review" }, { title: "Verify" }],
|
|
19
|
+
argsSchema: {
|
|
20
|
+
type: "object",
|
|
21
|
+
required: ["files"],
|
|
22
|
+
properties: {
|
|
23
|
+
files: { type: "array", items: { type: "string" } },
|
|
24
|
+
},
|
|
25
|
+
},
|
|
26
|
+
},
|
|
27
|
+
run: async (ctx) => {
|
|
28
|
+
ctx.phase("Review");
|
|
29
|
+
const reviews = await ctx.parallel(
|
|
30
|
+
ctx.args.files.map(
|
|
31
|
+
(file) => () => ctx.agent(`Review ${file}`, { label: `Review ${file}` })
|
|
32
|
+
)
|
|
33
|
+
);
|
|
34
|
+
|
|
35
|
+
ctx.phase("Verify");
|
|
36
|
+
const report = await ctx.step("report", () => ({ reviews }));
|
|
37
|
+
ctx.log(`Completed workflow run ${ctx.runId}`);
|
|
38
|
+
return report;
|
|
39
|
+
},
|
|
40
|
+
});
|
|
41
|
+
|
|
42
|
+
const session = await joinSession({ workflows: [reviewChanged] });
|
|
43
|
+
```
|
|
44
|
+
|
|
45
|
+
Workflow metadata contains a stable `name`, a human-readable `description`, declared `phases`, an optional `argsSchema`, and optional `limits`. Phase entries contain a `title` and optional `detail`.
|
|
46
|
+
|
|
47
|
+
## Declaring an argument shape
|
|
48
|
+
|
|
49
|
+
A workflow that reads `ctx.args` should declare `meta.argsSchema`, as the example above does. The schema records the workflow's expected input contract alongside its registration metadata.
|
|
50
|
+
|
|
51
|
+
Enforcement covers structure — types, required properties, and enum or const values. Finer constraints such as `minLength`, `pattern`, or `additionalProperties` are recorded in the declaration but not enforced. The accepted vocabulary is the `WorkflowJsonSchema` subset also used for subagent structured output: `type`, `required`, `enum`, `const`, recursive `properties`/`items`, and `anyOf`/`oneOf`/`allOf`. A `type` is one of `null`, `boolean`, `integer`, `number`, `string`, `array`, or `object`, or a non-empty array of those such as `["object", "null"]`. A declaration outside that subset is rejected at registration.
|
|
52
|
+
|
|
53
|
+
`argsSchema` is optional and backward compatible. A workflow that omits it behaves exactly as before, so state the expected shape in its `description`.
|
|
54
|
+
|
|
55
|
+
An extension calling `session.workflow.run(...)` is not validated against `argsSchema`; those arguments are typed through `defineWorkflow<TArgs>` instead. A workflow that reads `ctx.args` should still validate it rather than assume a shape because the declared subset does not enforce every constraint and JavaScript callers are not statically typed.
|
|
56
|
+
|
|
57
|
+
`defineWorkflow<TArgs, TResult>` accepts a `run(context)` function returning `Promise<TResult>`, where `TResult` is `JsonValue | void`. Objects, arrays, strings, numbers, booleans, and `null` are valid results. Returning `undefined` completes the workflow with no result. Other non-JSON values are rejected.
|
|
58
|
+
|
|
59
|
+
## Workflow context
|
|
60
|
+
|
|
61
|
+
The `run()` context provides:
|
|
62
|
+
|
|
63
|
+
- `ctx.runId`: Stable ID reused across resumed attempts.
|
|
64
|
+
- `ctx.args`: Invocation arguments, forwarded verbatim. When the caller omits `args`, this is `{}` rather than `undefined`.
|
|
65
|
+
- `ctx.agent(prompt, options?)`: Runs one workflow-owned subagent. Options are exactly `label`, `schema`, `model`, `agent`, `reasoningEffort`, `contextTier`, and `timeoutSeconds`. See [Subagent calls](#subagent-calls).
|
|
66
|
+
- `ctx.parallel(thunks)`: Runs thunks concurrently and awaits all of them (a barrier). A thunk that throws becomes `null` in the result array, so one failed item does not lose the rest. Cancellation and hard runtime failures (`ResponseError`, `ConnectionError`) are the exception — those propagate and reject the whole call, because they mean the run itself is in trouble rather than one item having failed. Handle them at run level; do not assume every failure arrives as a `null`. Rejects above 4096 items.
|
|
67
|
+
- `ctx.pipeline(items, ...stages)`: Flows each item through every stage without a barrier between stages, so one item can be in a later stage while another is still in an earlier one. Each stage is called as `(previous, item, index)`, where `previous` is the prior stage's result and `item` is the original input. A stage that throws drops that item to `null` and skips its remaining stages, with the same exception for cancellation and hard runtime failures. Rejects above 4096 items.
|
|
68
|
+
- `ctx.phase(title)`: Starts a named progress phase. This sets a single run-global value, so calling it from inside concurrent `parallel`/`pipeline` stages races. Call it at run-level transitions and distinguish concurrent work by `label` instead.
|
|
69
|
+
- `ctx.log(message)`: Appends a progress line. When a workflow bounds its own coverage (top-N, sampling), log what was dropped.
|
|
70
|
+
- `ctx.step(key, producer, options?)`: Journals the producer's JSON result under a stable key so a resume replays it without re-running the producer. A journaled (default) producer must return a JSON-serializable value; `undefined` or a non-JSON value is rejected. Pass `{ volatile: true }` to bypass the journal and run the producer every time.
|
|
71
|
+
|
|
72
|
+
The key is the _sole_ identity: neither the producer body nor its inputs contribute to it. A resume replays the cached value for a matching key even if the producer has since changed, so version the key (`"scan-v2"`) whenever its inputs or meaning change. Journaled producers are best-effort at-least-once and may run again across crashes or concurrent same-key callers, so keep side effects idempotent.
|
|
73
|
+
|
|
74
|
+
- `ctx.pause(key)`: Pauses at a durable, one-shot checkpoint. The first attempt records the checkpoint, pauses, and throws `AbortError` after cooperative cancellation. When the run resumes, the workflow starts again and the same checkpoint returns so execution can continue. Call it only from the main workflow flow, not inside `ctx.parallel()` or `ctx.pipeline()`.
|
|
75
|
+
- `ctx.session`: The session returned by `joinSession`. It refuses calls that start, resume, or pause a workflow run. Call `extensions_manage` with `operation: "guide"` to read more about the session APIs.
|
|
76
|
+
- `ctx.signal`: Cooperative cancellation signal for extension work and subprocesses.
|
|
77
|
+
- `ctx.workflow(...)`: Always rejects because nested workflows are not supported.
|
|
78
|
+
|
|
79
|
+
Workflow-owned subagents are intentionally hidden from `read_agent` and `write_agent`. Use the workflow observability APIs instead.
|
|
80
|
+
|
|
81
|
+
### Subagent calls
|
|
82
|
+
|
|
83
|
+
`ctx.agent(prompt, options?)` spawns one workflow-scoped subagent and awaits it. Without a schema it resolves to the subagent's final text. With `options.schema` it resolves to the parsed JSON value.
|
|
84
|
+
|
|
85
|
+
**Identical calls are memoized into one subagent.** Each call is journaled by its canonical prompt and options, including `label`. Two calls with the same prompt and the same options return one shared result — even when issued concurrently. To spawn N _independent_ subagents, give each a unique `label` or vary the prompt:
|
|
86
|
+
|
|
87
|
+
```js
|
|
88
|
+
// One subagent, awaited five times — almost certainly not what you want.
|
|
89
|
+
await ctx.parallel([1, 2, 3, 4, 5].map(() => () => ctx.agent("Find a bug")));
|
|
90
|
+
|
|
91
|
+
// Five independent subagents.
|
|
92
|
+
await ctx.parallel(
|
|
93
|
+
[1, 2, 3, 4, 5].map((i) => () => ctx.agent("Find a bug", { label: `finder:${i}` }))
|
|
94
|
+
);
|
|
95
|
+
```
|
|
96
|
+
|
|
97
|
+
**An ordinary failure resolves to `null` — it does not throw.** A subagent that errors, returns nothing, or (with a schema) produces output that still fails to parse or match after its one retry resolves `null`. Always guard the result before using it, including a bare `await ctx.agent(...)`:
|
|
98
|
+
|
|
99
|
+
```js
|
|
100
|
+
const finding = await ctx.agent(prompt, { label: "inspector" });
|
|
101
|
+
if (!finding) return { finding: null };
|
|
102
|
+
```
|
|
103
|
+
|
|
104
|
+
Cancellation and hard runtime failures — a reached limit, a durable-state failure — reject instead, aborting the run. When filtering results, prefer `v => v !== null` over `Boolean`, which also discards a valid `false`, `0`, or `""`.
|
|
105
|
+
|
|
106
|
+
**`schema` is a structural subset of JSON Schema, not a validator.** Honored: `type`, `required`, `enum`, `const`, recursive `properties`/`items`, and `anyOf`/`oneOf`/`allOf` — where `oneOf` is treated as `anyOf`, meaning at least one branch matches rather than exactly one. Ignored and _not_ enforced: `additionalProperties`, `pattern`, `minLength`/`maxLength`, `format`, numeric ranges, and boolean schemas. Do not rely on an ignored keyword to constrain a result.
|
|
107
|
+
|
|
108
|
+
The runtime always parses and validates the returned JSON against that workflow subset. On a parse or match failure, it sends up to two correction turns to the same subagent; it does not spawn replacement subagents or repeat the original task.
|
|
109
|
+
|
|
110
|
+
Eligible local first-party model routes also use provider-native structured output to strengthen generation. Native selection fails closed: the selected CAPI model must explicitly report structured-output support, the wire route must support native formats, and the schema must fit a conservative provider subset. That subset requires an object root, typed nodes, non-empty object properties, every property listed in `required`, `additionalProperties: false` on every object, object-shaped array items, and bounded depth, property count, enum size, and serialized size. It accepts nested `anyOf`, descriptions, and enums, but rejects root `anyOf`, references, boolean schemas, `allOf`, `oneOf`, `const`, and other unsupported keywords.
|
|
111
|
+
|
|
112
|
+
AHP subagents, HydraFusion-selected children, BYOK providers, models without the capability, unknown routes, and schemas outside the native subset keep prompt-based JSON coercion. They retain the same parsing, validation, and same-agent correction behavior, so workflow authors use one `ctx.agent(..., { schema })` API regardless of the selected path.
|
|
113
|
+
|
|
114
|
+
**Per-agent deadlines are optional and runtime-owned.** `options.timeoutSeconds`
|
|
115
|
+
must be finite and positive, at most `2_147_483.647`. It covers this call's
|
|
116
|
+
concurrency and journal queueing, preparation, agent execution, and same-agent
|
|
117
|
+
schema correction turns. Durable writes and cancellation cleanup are allowed to
|
|
118
|
+
finish, so the deadline is soft rather than a guarantee of an immediate response.
|
|
119
|
+
|
|
120
|
+
An expired call cancels only its own agent subtree and rejects with JSON-RPC
|
|
121
|
+
`data.code: "workflow_agent_timeout"`. It does not cancel `ctx.signal` or sibling
|
|
122
|
+
calls, consume an extra agent admission, or memoize a failed result. Catch that
|
|
123
|
+
specific failure inside an individual thunk if the workflow should continue.
|
|
124
|
+
An uncaught error still fails the workflow normally. A run cancellation or
|
|
125
|
+
reached run limit takes precedence over an agent deadline; the existing run
|
|
126
|
+
limits and accounting still apply. A cleanup failure rejects with
|
|
127
|
+
`workflow_agent_cleanup_failed`, never a successful agent result. Omit the option
|
|
128
|
+
unless a deadline is known or requested.
|
|
129
|
+
|
|
130
|
+
### Choosing between pipeline and parallel
|
|
131
|
+
|
|
132
|
+
Prefer `pipeline` for multi-stage work. It has no barrier between stages, so each item advances as soon as its own prior stage finishes.
|
|
133
|
+
|
|
134
|
+
Reach for a barrier — `parallel` between stages — only when a stage genuinely needs every prior result at once: deduplicating or merging across the full set, an early exit based on the total, or a prompt that compares one result against the others. Needing to map, filter, or flatten is not a reason to use a barrier; do that inside a pipeline stage. Barrier latency is real: if the slowest of N subagents takes three times the fastest, a barrier wastes the rest of the pool's time.
|
|
135
|
+
|
|
136
|
+
## Resource limits
|
|
137
|
+
|
|
138
|
+
Limits may be declared in `meta.limits` and overridden per invocation. Every limit is optional and must be positive when present; an omitted limit leaves that dimension unbounded, except that an omitted `maxConcurrentSubagents` falls back to `maxTotalSubagents`, so a declared total cap also bounds concurrency.
|
|
139
|
+
|
|
140
|
+
Set a ceiling only from real knowledge of what the workflow costs, or because the user named one. A guessed ceiling does not make a run safer: it stops a healthy run partway with `workflow_limit_reached`, after that run has already spent credits. SDK-initiated `run` and `resume` do not request permission, so a caller that wants a ceiling must set it deliberately from a cost it already knows.
|
|
141
|
+
|
|
142
|
+
```js
|
|
143
|
+
// Only when the cost profile is known, or the user asked for this ceiling.
|
|
144
|
+
limits: { maxTotalSubagents: 10 },
|
|
145
|
+
```
|
|
146
|
+
|
|
147
|
+
- `maxConcurrentSubagents`: Positive integer concurrent-subagent cap. Additional subagents wait in a queue. Queueing applies backpressure and does not fail the run.
|
|
148
|
+
- `maxTotalSubagents`: Positive integer cumulative admission cap. An attempted subagent beyond the cap ends the attempt with failure kind `maxTotalSubagents`.
|
|
149
|
+
- `timeoutSeconds`: Positive finite number of seconds, including positive fractions, capped at `2_147_483.647`. It measures accumulated active-execution time across attempts, including the extension body, subprocess waits, queued-agent waits, and sleeps. Time between attempts is excluded. The timeout is soft because already-running work may take time to stop. Its failure kind is `timeoutSeconds`.
|
|
150
|
+
- `maxAiCredits`: Positive finite AI-credit budget for the whole run's workflow subagent subtree, including descendants. AI credits are GitHub Copilot's universal usage metric. This is a soft, post-paid ceiling, so completed or parallel turns can settle above it before the run stops. Accounting is fail-closed: an accounting failure stops a budgeted run rather than allowing untracked use. Its failure kind is `maxAiCredits`.
|
|
151
|
+
|
|
152
|
+
`maxTotalSubagents`, `timeoutSeconds`, and `maxAiCredits` use reject-and-retry semantics. A rejected attempt ends with run status `error` and `failure.type` set to `workflow_limit_reached`. The failed run keeps its ID, arguments, journal, and accounting. Resume the run with a raised limit when additional work is approved. Previously consumed resources still count.
|
|
153
|
+
|
|
154
|
+
## Run and resume
|
|
155
|
+
|
|
156
|
+
`run` waits for the current attempt to settle. Run by registered name or handle:
|
|
157
|
+
|
|
158
|
+
```ts
|
|
159
|
+
const run = await session.workflow.run("review-changed", {
|
|
160
|
+
args: { files: ["src/a.ts"] },
|
|
161
|
+
limits: { maxAiCredits: 3 },
|
|
162
|
+
notifyOnComplete: true,
|
|
163
|
+
logPhaseNames: true,
|
|
164
|
+
});
|
|
165
|
+
|
|
166
|
+
if (run.status === "completed") {
|
|
167
|
+
console.log(run.result);
|
|
168
|
+
} else {
|
|
169
|
+
console.error(`run ${run.runId} ended as ${run.status}`, run.failure ?? run.error);
|
|
170
|
+
}
|
|
171
|
+
```
|
|
172
|
+
|
|
173
|
+
The name overload is:
|
|
174
|
+
|
|
175
|
+
```ts
|
|
176
|
+
session.workflow.run(
|
|
177
|
+
name: string,
|
|
178
|
+
options?: {
|
|
179
|
+
args?: JsonValue;
|
|
180
|
+
limits?: WorkflowLimitOverrides;
|
|
181
|
+
notifyOnComplete?: boolean;
|
|
182
|
+
logPhaseNames?: boolean;
|
|
183
|
+
},
|
|
184
|
+
): Promise<WorkflowRunResult>;
|
|
185
|
+
```
|
|
186
|
+
|
|
187
|
+
Resume by run ID without resending the name or arguments:
|
|
188
|
+
|
|
189
|
+
```ts
|
|
190
|
+
const run = await session.workflow.resume(runId, {
|
|
191
|
+
limits: { maxAiCredits: 6 },
|
|
192
|
+
notifyOnComplete: true,
|
|
193
|
+
logPhaseNames: true,
|
|
194
|
+
});
|
|
195
|
+
```
|
|
196
|
+
|
|
197
|
+
The signature is:
|
|
198
|
+
|
|
199
|
+
```ts
|
|
200
|
+
session.workflow.resume(
|
|
201
|
+
runId: string,
|
|
202
|
+
options?: {
|
|
203
|
+
limits?: WorkflowLimitOverrides;
|
|
204
|
+
notifyOnComplete?: boolean;
|
|
205
|
+
logPhaseNames?: boolean;
|
|
206
|
+
},
|
|
207
|
+
): Promise<WorkflowRunResult>;
|
|
208
|
+
```
|
|
209
|
+
|
|
210
|
+
Set `notifyOnComplete` to `true` for workflows that are likely to be invoked by an agent, so the originating session is notified when the workflow completes. Set it to `false` for workflows intended to be invoked programmatically, where the caller awaits the result directly. Set `logPhaseNames` to emit workflow phase names to the session transcript. Both options apply to new and resumed runs.
|
|
211
|
+
|
|
212
|
+
Both resolve with the run envelope (`WorkflowRunResult`) for **every** outcome—`completed`, `error`, `halted`, `paused`, and `cancelled` alike. Inspect `status` and read `result` only when the run completed; a limit breach carries a typed `failure`. A `paused` envelope means that the current attempt settled, not that the durable run is permanently finished. Resume the same run ID to start another attempt with its journal and accounting intact. SDK-initiated `run` and `resume` do not request permission, so they have no declined outcome. They still enforce execution eligibility, input validation, and active-run limits. Recognized pre-execution resume failures throw `WorkflowResumeError`, whose `code` is one of `not_found`, `non_resumable`, `workflow_run_not_resumable`, `already_active`, `workflow_already_running`, `workflow_limits_invalid`, `workflow_session_disposed`, `workflow_storage_unavailable`, or `workflow_storage_corrupt`.
|
|
213
|
+
|
|
214
|
+
If the runtime that owns a started run disappears, the run remains active until its existing lease expires. The next observation reconciles it to `halted`, after which it can be resumed through the same API. Resume reuses durable journal entries and durable AI credit spend; spend that was not durably stored before the runtime disappeared is not reconstructed.
|
|
215
|
+
|
|
216
|
+
Use `start` with the same name/handle and options to return immediately after
|
|
217
|
+
runtime admission instead of waiting for completion:
|
|
218
|
+
|
|
219
|
+
```ts
|
|
220
|
+
const admitted = await session.workflow.start("review-changed", {
|
|
221
|
+
args: { files: ["src/a.ts"] },
|
|
222
|
+
notifyOnComplete: false,
|
|
223
|
+
});
|
|
224
|
+
console.log(`Admitted run ${admitted.runId}: ${admitted.status}`);
|
|
225
|
+
const settled = await session.workflow.waitForRun(admitted.runId);
|
|
226
|
+
```
|
|
227
|
+
|
|
228
|
+
The admitted envelope is not a successful result; inspect the terminal status
|
|
229
|
+
before using `result`. Admission still enforces eligibility, input validation and
|
|
230
|
+
active-run limits, and a pre-admission failure rejects without returning a run.
|
|
231
|
+
`start` does not change `run` or `resume`'s blocking behavior. Like `run`, it is
|
|
232
|
+
not allowed from a workflow body because nested workflows are unsupported.
|
|
233
|
+
|
|
234
|
+
Pause a running attempt from outside its workflow body:
|
|
235
|
+
|
|
236
|
+
```ts
|
|
237
|
+
const paused = await session.workflow.pause(runId);
|
|
238
|
+
```
|
|
239
|
+
|
|
240
|
+
Inside a workflow body, use a durable checkpoint instead:
|
|
241
|
+
|
|
242
|
+
```ts
|
|
243
|
+
await ctx.step("prepare", prepareInput);
|
|
244
|
+
await ctx.pause("review-ready");
|
|
245
|
+
await ctx.agent("Review the prepared input");
|
|
246
|
+
```
|
|
247
|
+
|
|
248
|
+
The first attempt pauses at `"review-ready"` and ends through cooperative cancellation. On resume, the workflow starts from the beginning, reuses the journaled step, returns from the checkpoint, and continues.
|
|
249
|
+
|
|
250
|
+
## Observe a run
|
|
251
|
+
|
|
252
|
+
The calling session can inspect its own workflow runs independently of its current execution eligibility. An empty registry enumerates successfully; losing eligibility does not hide already-admitted runs or terminal history. Observation still requires a valid, non-disposed session, and validation, missing-run, and storage errors still propagate.
|
|
253
|
+
|
|
254
|
+
Workflow storage requires SQLite support from a custom session filesystem. A provider without that capability reports `workflow_storage_unavailable`, not an empty registry or a local-storage fallback.
|
|
255
|
+
|
|
256
|
+
Compaction waits at most five seconds for its optional active-workflow summary. If storage fails or times out, compaction logs a warning and continues without that summary; aborting compaction cancels the wait. This does not change the results or error handling of explicit workflow observation calls.
|
|
257
|
+
|
|
258
|
+
Observation does not restore execution eligibility. Starting, resuming, pausing, or cancelling runs, and workflow-owned agent, log, and journal/checkpoint operations still require eligible credentials (token-based billing or trusted HMAC authentication). Ineligible execution requests fail with JSON-RPC `-32601` and `data.code: "dynamic_workflows_unavailable"`.
|
|
259
|
+
|
|
260
|
+
```ts
|
|
261
|
+
const runs = await session.workflow.listRuns();
|
|
262
|
+
const runsPage = await session.workflow.listRuns({
|
|
263
|
+
beforeSeq,
|
|
264
|
+
limit,
|
|
265
|
+
});
|
|
266
|
+
const detail = await session.workflow.getRunDetail(runId);
|
|
267
|
+
const progressPage = await session.workflow.getRunProgress(runId, {
|
|
268
|
+
phaseId,
|
|
269
|
+
afterSeq,
|
|
270
|
+
limit,
|
|
271
|
+
});
|
|
272
|
+
```
|
|
273
|
+
|
|
274
|
+
- `listRuns()` returns only the runs array from the newest default page of this session's durable workflow runs. This overload preserves the original convenience API.
|
|
275
|
+
- `listRuns({ afterSeq, limit })` or `listRuns({ beforeSeq, limit })` returns the full page. Its `oldestSeq`, `newestSeq`, `hasMoreNewer`, and `omittedOlder` fields let callers continue paging without raw RPC calls.
|
|
276
|
+
- `getRunDetail(runId)` returns phases, prompt-safe agent summaries, and the latest progress page. Each current-runtime agent summary includes `consumedNanoAiu`, the known spend from that direct agent and its descendants. Older runtimes omit the field, and historical agents without attributable charge rows also omit it when the run contains unattributed spend.
|
|
277
|
+
- `getRunProgress(runId, options?)` pages progress forward, backward, by phase, or from the latest tail.
|
|
278
|
+
- Both paging calls take at most one cursor: `afterSeq` pages forward and `beforeSeq` pages backward, each exclusive of the given sequence number. A request with both fails with JSON-RPC `-32602` and `data.code: "workflow_runs_invalid_cursor"` from `listRuns`, or `"workflow_progress_invalid_cursor"` from `getRunProgress`.
|
|
279
|
+
|
|
280
|
+
`getRun(runId)` reads the latest run envelope. `pause(runId)` pauses a running attempt and returns its `paused` envelope. `cancel(runId)` cancels a run and returns its terminal envelope.
|
|
281
|
+
|
|
282
|
+
`waitForRun(runId, options?)` resolves with the current attempt's envelope once it settles into `completed`, `error`, `halted`, `paused`, or `cancelled`. It resolves immediately when the current attempt has already settled:
|
|
283
|
+
|
|
284
|
+
```ts
|
|
285
|
+
const settled = await session.workflow.waitForRun(runId);
|
|
286
|
+
if (settled.status === "completed") {
|
|
287
|
+
console.log(settled.result);
|
|
288
|
+
}
|
|
289
|
+
```
|
|
290
|
+
|
|
291
|
+
It watches `workflow.run_updated` and re-reads the durable envelope on each invalidation, collapsing a burst of events into a single in-flight read. A low-frequency periodic re-read runs alongside the subscription, so a dropped or missing invalidation degrades into a slightly late resolution rather than an unbounded wait. Pass a `signal` to stop waiting:
|
|
292
|
+
|
|
293
|
+
```ts
|
|
294
|
+
const controller = new AbortController();
|
|
295
|
+
setTimeout(() => controller.abort(), 30_000);
|
|
296
|
+
const settled = await session.workflow.waitForRun(runId, { signal: controller.signal });
|
|
297
|
+
```
|
|
298
|
+
|
|
299
|
+
Aborting rejects the wait and has no effect on the run, which keeps executing—use `pause(runId)` or `cancel(runId)` to stop it. The resolved object is a snapshot of that settled attempt. If its status is `paused`, a later resume updates the durable envelope under the same run ID. Call `getRun(runId)` to read the latest envelope. `isWorkflowRunTerminal(status)` exposes the same current-attempt settlement test for callers driving their own loop.
|
|
300
|
+
|
|
301
|
+
Listen for the ephemeral `workflow.run_updated` event. Its `{ runId, revision }` payload is an invalidation signal. Re-read the desired API when a newer monotonic revision arrives.
|
|
302
|
+
|
|
303
|
+
Revisions cover durable lifecycle, accounting, phase, agent, and progress changes. Continuous read-time fields can change without a new revision. These include `observedAt`, active-time calculations, live counts, and a live agent's status or prompt-safe activity text. Workflow prompts are never exposed by these APIs. A run is visible only through the session that owns it.
|
package/package.json
CHANGED
|
@@ -1,6 +1,136 @@
|
|
|
1
1
|
{
|
|
2
|
-
|
|
3
|
-
|
|
4
|
-
|
|
5
|
-
|
|
6
|
-
|
|
2
|
+
"name": "@microsoft/copilot-sdk",
|
|
3
|
+
"repository": {
|
|
4
|
+
"type": "git",
|
|
5
|
+
"url": "https://github.com/github/copilot-agent-runtime.git",
|
|
6
|
+
"directory": "src/sdk/nodejs"
|
|
7
|
+
},
|
|
8
|
+
"version": "2.0.0-preview.0",
|
|
9
|
+
"copilotCliVersion": "1.0.106-9.unstable.r43755488033.g11df7b2",
|
|
10
|
+
"description": "TypeScript SDK for programmatic control of GitHub Copilot CLI via JSON-RPC",
|
|
11
|
+
"main": "./dist/cjs/index.js",
|
|
12
|
+
"types": "./dist/index.d.ts",
|
|
13
|
+
"exports": {
|
|
14
|
+
".": {
|
|
15
|
+
"import": {
|
|
16
|
+
"types": "./dist/index.d.ts",
|
|
17
|
+
"default": "./dist/index.js"
|
|
18
|
+
},
|
|
19
|
+
"require": {
|
|
20
|
+
"types": "./dist/index.d.ts",
|
|
21
|
+
"default": "./dist/cjs/index.js"
|
|
22
|
+
}
|
|
23
|
+
},
|
|
24
|
+
"./extension": {
|
|
25
|
+
"import": {
|
|
26
|
+
"types": "./dist/extension.d.ts",
|
|
27
|
+
"default": "./dist/extension.js"
|
|
28
|
+
},
|
|
29
|
+
"require": {
|
|
30
|
+
"types": "./dist/extension.d.ts",
|
|
31
|
+
"default": "./dist/cjs/extension.js"
|
|
32
|
+
}
|
|
33
|
+
}
|
|
34
|
+
},
|
|
35
|
+
"type": "module",
|
|
36
|
+
"scripts": {
|
|
37
|
+
"auth:refresh": "node ../scripts/npm-auth-refresh.mjs --run",
|
|
38
|
+
"clean": "rimraf --glob dist *.tgz",
|
|
39
|
+
"build": "node --import tsx esbuild-copilotsdk-nodejs.ts",
|
|
40
|
+
"pack:release": "npm run verify:dependency-policy && tsx scripts/package-sdk.ts",
|
|
41
|
+
"verify:dependency-policy": "tsx scripts/verify-dependency-policy.ts",
|
|
42
|
+
"verify:release-packages": "tsx scripts/verify-release-packages.ts",
|
|
43
|
+
"release:manifest": "tsx scripts/release-manifest.ts",
|
|
44
|
+
"prepare:runtime": "tsx scripts/prepare-runtime.ts",
|
|
45
|
+
"test": "vitest run",
|
|
46
|
+
"test:unit": "vitest run --exclude=\"test/e2e/**\"",
|
|
47
|
+
"test:codegen": "vitest run --exclude=\"test/e2e/**\" codegen.test.ts legacy-parameters.test.ts",
|
|
48
|
+
"test:watch": "vitest",
|
|
49
|
+
"format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\" --ignore-path .prettierignore",
|
|
50
|
+
"format:check": "prettier --check \"src/**/*.ts\" \"test/**/*.ts\" --ignore-path .prettierignore",
|
|
51
|
+
"lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
|
|
52
|
+
"lint:fix": "eslint --fix \"src/**/*.ts\" \"test/**/*.ts\"",
|
|
53
|
+
"typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json",
|
|
54
|
+
"generate": "cd ../scripts/codegen && npm run generate",
|
|
55
|
+
"generate:java-compat-fixtures": "tsx test/generate-java-compat-fixtures.ts",
|
|
56
|
+
"set:cli-version": "node scripts/set-cli-version.js",
|
|
57
|
+
"update:protocol-version": "tsx scripts/update-protocol-version.ts",
|
|
58
|
+
"vendor:tools": "tsx scripts/vendor-build-tools.ts",
|
|
59
|
+
"prepublishOnly": "npm run build",
|
|
60
|
+
"package": "npm run clean && npm run build && node scripts/set-version.js && npm run pack:release && npm version 0.0.0-dev --no-git-tag-version --allow-same-version"
|
|
61
|
+
},
|
|
62
|
+
"keywords": [
|
|
63
|
+
"github",
|
|
64
|
+
"copilot",
|
|
65
|
+
"sdk",
|
|
66
|
+
"jsonrpc",
|
|
67
|
+
"agent"
|
|
68
|
+
],
|
|
69
|
+
"author": "Microsoft",
|
|
70
|
+
"license": "MIT",
|
|
71
|
+
"dependencies": {
|
|
72
|
+
"koffi": "3.3.6",
|
|
73
|
+
"lossless-json": "4.3.3",
|
|
74
|
+
"vscode-jsonrpc": "10.0.0",
|
|
75
|
+
"zod": "4.6.7"
|
|
76
|
+
},
|
|
77
|
+
"devDependencies": {
|
|
78
|
+
"@hpke/core": "^1.9.0",
|
|
79
|
+
"@microsoft/agent-host-protocol-v09": "npm:@microsoft/agent-host-protocol@0.9.0",
|
|
80
|
+
"@platformatic/vfs": "^0.5.0",
|
|
81
|
+
"@types/node": "^26.6.5",
|
|
82
|
+
"@types/semver": "7.8.0",
|
|
83
|
+
"@types/ws": "^8.18.1",
|
|
84
|
+
"@typescript-eslint/eslint-plugin": "^8.72.0",
|
|
85
|
+
"@typescript-eslint/parser": "^8.72.0",
|
|
86
|
+
"@vitest/coverage-v8": "^5.1.0",
|
|
87
|
+
"esbuild": "^0.28.1",
|
|
88
|
+
"eslint": "^10.13.0",
|
|
89
|
+
"file-entry-cache": "file:./scripts/eslint-file-cache",
|
|
90
|
+
"glob": "^14.0.3",
|
|
91
|
+
"json-schema": "^0.4.0",
|
|
92
|
+
"json-schema-to-typescript": "^16.0.0",
|
|
93
|
+
"jsonc-parser": "^3.3.1",
|
|
94
|
+
"prettier": "file:../../../third_party/build-tools/prettier-3.8.1",
|
|
95
|
+
"rimraf": "^6.1.2",
|
|
96
|
+
"semver": "^7.7.3",
|
|
97
|
+
"tar": "^7.5.22",
|
|
98
|
+
"tsx": "file:../../../third_party/build-tools/tsx-4.23.13",
|
|
99
|
+
"typescript": "^5.0.0",
|
|
100
|
+
"vite": "file:../../../third_party/build-tools/vite-8.3.4",
|
|
101
|
+
"vitest": "^5.1.0",
|
|
102
|
+
"ws": "^8.21.0",
|
|
103
|
+
"yaml": "^2.8.3"
|
|
104
|
+
},
|
|
105
|
+
"overrides": {
|
|
106
|
+
"file-entry-cache": "$file-entry-cache",
|
|
107
|
+
"glob": "$glob",
|
|
108
|
+
"minimatch": "11.0.2",
|
|
109
|
+
"prettier": "$prettier",
|
|
110
|
+
"vite": "$vite"
|
|
111
|
+
},
|
|
112
|
+
"engines": {
|
|
113
|
+
"node": "^20.19.0 || >=22.12.0"
|
|
114
|
+
},
|
|
115
|
+
"files": [
|
|
116
|
+
"dist/**/*",
|
|
117
|
+
"!dist/tsconfig.tsbuildinfo",
|
|
118
|
+
"docs/**/*",
|
|
119
|
+
"README.md"
|
|
120
|
+
],
|
|
121
|
+
"copilotRuntime": {
|
|
122
|
+
"sourceSha": "11df7b2f4261f1febf57351922f4daf3ba33dc3a",
|
|
123
|
+
"version": "1.0.106-9.unstable.r43755488033.g11df7b2",
|
|
124
|
+
"visibility": "public"
|
|
125
|
+
},
|
|
126
|
+
"optionalDependencies": {
|
|
127
|
+
"@microsoft/copilot-sdk-darwin-arm64": "2.0.0-preview.0",
|
|
128
|
+
"@microsoft/copilot-sdk-darwin-x64": "2.0.0-preview.0",
|
|
129
|
+
"@microsoft/copilot-sdk-linux-arm64": "2.0.0-preview.0",
|
|
130
|
+
"@microsoft/copilot-sdk-linux-x64": "2.0.0-preview.0",
|
|
131
|
+
"@microsoft/copilot-sdk-linuxmusl-arm64": "2.0.0-preview.0",
|
|
132
|
+
"@microsoft/copilot-sdk-linuxmusl-x64": "2.0.0-preview.0",
|
|
133
|
+
"@microsoft/copilot-sdk-win32-arm64": "2.0.0-preview.0",
|
|
134
|
+
"@microsoft/copilot-sdk-win32-x64": "2.0.0-preview.0"
|
|
135
|
+
}
|
|
136
|
+
}
|