@github-tools/sdk 1.4.0 → 1.5.0

package/README.md

@@ -365,7 +365,9 @@ All other `ToolLoopAgent` options (`stopWhen`, `toolChoice`, `onStepFinish`, etc
 
 ### `createDurableGithubAgent(options)`
 
-Returns a `DurableAgent` instance for use inside Vercel Workflow SDK functions. Every LLM call and tool execution runs as a durable step with automatic retries and crash recovery.
+Returns a `DurableGithubAgent` instance for use inside Vercel Workflow SDK functions. Every LLM call and tool execution runs as a durable step with automatic retries and crash recovery.
+
+Supports both `.stream()` (real-time output to a writable) and `.generate()` (non-streaming, returns the full text response).
 
 Requires the optional peer dependencies `workflow` and `@workflow/ai`:
 
@@ -373,6 +375,8 @@ Requires the optional peer dependencies `workflow` and `@workflow/ai`:
 pnpm add workflow @workflow/ai
 ```
 
+#### Streaming (chat UI)
+
 ```ts
 import { createDurableGithubAgent } from '@github-tools/sdk/workflow'
 import { getWritable } from 'workflow'
@@ -390,7 +394,26 @@ async function chatWorkflow(messages: ModelMessage[], token: string) {
 }
 ```
 
-All presets (`code-review`, `issue-triage`, `ci-ops`, `repo-explorer`, `maintainer`) work with `createDurableGithubAgent`. The options are the same as `createGithubAgent` except it returns a `DurableAgent` instead of a `ToolLoopAgent`.
+#### Non-streaming (bot / background job — needs `"use step"`)
+
+```ts
+import { createGithubAgent } from '@github-tools/sdk'
+
+async function agentTurn(prompt: string) {
+  "use step"
+  const agent = createGithubAgent({
+    model: 'anthropic/claude-sonnet-4.6',
+    preset: 'code-review',
+    requireApproval: false,
+  })
+  const { text } = await agent.generate({ prompt })
+  return text
+}
+```
+
+> See [`examples/pr-review-bot`](../../examples/pr-review-bot) for a complete PR review bot built with Chat SDK and Vercel Workflow.
+
+All presets (`code-review`, `issue-triage`, `ci-ops`, `repo-explorer`, `maintainer`) work with `createDurableGithubAgent`. Options mirror `createGithubAgent` with additional pass-through for `DurableAgentOptions` fields like `experimental_telemetry`, `onStepFinish`, `onFinish`, and `prepareStep`.
 
 > **Note:** `requireApproval` is accepted but currently ignored by `DurableAgent` — the Workflow SDK does not yet support interactive tool approval.
 

package/dist/workflow.d.mts

@@ -1,10 +1,81 @@
-import { n as createGithubAgent, t as CreateGithubAgentOptions } from "./agents-C6nqZiYp.mjs";
+import { J as ToolOverrides, n as createGithubAgent, t as CreateGithubAgentOptions } from "./agents-C6nqZiYp.mjs";
 import { ApprovalConfig, GithubToolPreset, GithubTools, GithubToolsOptions, GithubWriteToolName, createGithubTools } from "./index.mjs";
 import * as ai from "ai";
-import { CompatibleLanguageModel, DurableAgent } from "@workflow/ai/agent";
+import { FinishReason, LanguageModelResponseMetadata, LanguageModelUsage, ModelMessage, StepResult, StopCondition, ToolSet } from "ai";
+import { CompatibleLanguageModel, DurableAgentOptions, DurableAgentStreamOptions, DurableAgentStreamResult } from "@workflow/ai/agent";
 
 //#region src/workflow.d.ts
-type CreateDurableGithubAgentOptions = {
+/**
+ * Result of {@link DurableGithubAgent.generate}.
+ */
+interface DurableGithubAgentGenerateResult<TTools extends ToolSet = ToolSet> {
+  text: string;
+  finishReason: FinishReason;
+  usage: LanguageModelUsage;
+  steps: StepResult<TTools>[];
+  response: LanguageModelResponseMetadata & {
+    messages: ModelMessage[];
+  };
+}
+/**
+ * A wrapper around the Workflow SDK's `DurableAgent` that adds a non-streaming
+ * `.generate()` method alongside the existing `.stream()`.
+ *
+ * - `.stream()` — delegates to `DurableAgent.stream()`, each tool call is
+ *   an individually retriable workflow step. Works in workflow context.
+ * - `.generate()` — uses `generateText` from the AI SDK for non-streaming
+ *   execution. Must be called from within a `"use step"` function in
+ *   workflow context (the Workflow runtime blocks raw I/O in workflow scope).
+ */
+declare class DurableGithubAgent<TTools extends ToolSet = ToolSet> {
+  private agent;
+  private _model;
+  private _instructions?;
+  private _telemetry?;
+  private _tools;
+  constructor(options: DurableAgentOptions<TTools>);
+  /** The tool set configured for this agent. */
+  get tools(): TTools;
+  /**
+   * Stream the agent's response. Delegates directly to `DurableAgent.stream()`.
+   * Works in workflow context — each tool call is a durable step.
+   */
+  stream<TStreamTools extends TTools = TTools, OUTPUT = never, PARTIAL_OUTPUT = never>(options: DurableAgentStreamOptions<TStreamTools, OUTPUT, PARTIAL_OUTPUT>): Promise<DurableAgentStreamResult<TStreamTools, OUTPUT>>;
+  /**
+   * Generate a non-streaming response using `generateText` from the AI SDK.
+   *
+   * In workflow context this **must** be called from within a `"use step"`
+   * function, because the Workflow runtime blocks direct I/O (HTTP calls)
+   * at the workflow scope level.
+   *
+   * @example
+   * ```ts
+   * async function agentTurn(prompt: string) {
+   *   "use step"
+   *   const agent = createDurableGithubAgent({
+   *     model: 'anthropic/claude-sonnet-4.6',
+   *     preset: 'code-review',
+   *   })
+   *   const { text } = await agent.generate({ prompt })
+   *   return text
+   * }
+   * ```
+   */
+  generate({
+    prompt,
+    stopWhen
+  }: {
+    prompt: string;
+    stopWhen?: StopCondition<TTools> | Array<StopCondition<TTools>>;
+  }): Promise<DurableGithubAgentGenerateResult<TTools>>;
+}
+/**
+ * Options for creating a durable GitHub agent via {@link createDurableGithubAgent}.
+ *
+ * Extends all `DurableAgentOptions` (temperature, telemetry, callbacks, etc.)
+ * and adds GitHub-specific fields (token, preset, approval config).
+ */
+type CreateDurableGithubAgentOptions = Omit<DurableAgentOptions, 'model' | 'tools' | 'instructions'> & {
   model: string | CompatibleLanguageModel | (() => Promise<CompatibleLanguageModel>);
   /**
    * GitHub personal access token.
@@ -14,21 +85,22 @@ type CreateDurableGithubAgentOptions = {
   preset?: GithubToolPreset | GithubToolPreset[];
   requireApproval?: ApprovalConfig;
   instructions?: string;
-  additionalInstructions?: string; /** Maximum number of LLM calls before stopping. Unlimited by default. */
-  maxSteps?: number;
-  temperature?: number;
+  additionalInstructions?: string;
 };
 /**
  * Create a pre-configured durable GitHub agent powered by Vercel Workflow SDK's `DurableAgent`.
  *
- * Each tool call runs as a durable step with automatic retries and observability.
- * Must be used inside a `"use workflow"` function.
+ * Returns a {@link DurableGithubAgent} with two interaction modes:
+ *
+ * - `.stream()` — works directly in workflow scope; each tool call is a durable step.
+ * - `.generate()` — uses `generateText` from the AI SDK; must be called from
+ *   within a `"use step"` function when running inside a workflow.
  *
  * **Note:** `requireApproval` is accepted for forward-compatibility but is currently
  * ignored by `DurableAgent` — the Workflow SDK does not yet support interactive tool
  * approval. All tools execute immediately without user confirmation.
  *
- * @example
+ * @example Streaming (chat UI — works in workflow scope)
  * ```ts
  * import { createDurableGithubAgent } from '@github-tools/sdk/workflow'
  * import { getWritable } from 'workflow'
@@ -45,6 +117,21 @@ type CreateDurableGithubAgentOptions = {
  *   await agent.stream({ messages, writable })
  * }
  * ```
+ *
+ * @example Non-streaming (bot / background job — needs "use step")
+ * ```ts
+ * import { createDurableGithubAgent } from '@github-tools/sdk/workflow'
+ *
+ * async function agentTurn(prompt: string) {
+ *   "use step"
+ *   const agent = createDurableGithubAgent({
+ *     model: 'anthropic/claude-sonnet-4.6',
+ *     preset: 'code-review',
+ *   })
+ *   const { text } = await agent.generate({ prompt })
+ *   return text
+ * }
+ * ```
  */
 declare function createDurableGithubAgent({
   model,
@@ -54,7 +141,7 @@ declare function createDurableGithubAgent({
   instructions,
   additionalInstructions,
   ...agentOptions
-}: CreateDurableGithubAgentOptions): DurableAgent<Partial<{
+}: CreateDurableGithubAgentOptions): DurableGithubAgent<Partial<{
   getRepository: ai.Tool<{
     owner: string;
     repo: string;
@@ -723,5 +810,5 @@ declare function createDurableGithubAgent({
   }>;
 }>>;
 //#endregion
-export { type ApprovalConfig, CreateDurableGithubAgentOptions, type CreateGithubAgentOptions, type GithubToolPreset, type GithubTools, type GithubToolsOptions, type GithubWriteToolName, createDurableGithubAgent, createGithubAgent, createGithubTools };
+export { type ApprovalConfig, CreateDurableGithubAgentOptions, type CreateGithubAgentOptions, DurableGithubAgent, DurableGithubAgentGenerateResult, type GithubToolPreset, type GithubTools, type GithubToolsOptions, type GithubWriteToolName, type ToolOverrides, createDurableGithubAgent, createGithubAgent, createGithubTools };
 //# sourceMappingURL=workflow.d.mts.map

package/dist/workflow.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.d.mts","names":[],"sources":["../src/workflow.ts"],"mappings":";;;;;;KAMY,+BAAA;EACV,KAAA,WAAgB,uBAAA,UAAiC,OAAA,CAAQ,uBAAA;;AAD3D;;;EAME,KAAA;EACA,MAAA,GAAS,gBAAA,GAAmB,gBAAA;EAC5B,eAAA,GAAkB,cAAA;EAClB,YAAA;EACA,sBAAA,WAFkB;EAIlB,QAAA;EACA,WAAA;AAAA;;;;;;;;;;;;;;;;AA+BF;;;;;;;;;;;;;iBAAgB,wBAAA,CAAA;EACd,KAAA;EACA,KAAA;EACA,MAAA;EACA,eAAA;EACA,YAAA;EACA,sBAAA;EAAA,GACG;AAAA,GACF,+BAAA,GAA+B,YAAA,CAAA,OAAA;iBAAA,EAAA,CAAA,IAAA"}
+{"version":3,"file":"workflow.d.mts","names":[],"sources":["../src/workflow.ts"],"mappings":";;;;;;;;;;UAUiB,gCAAA,gBAAgD,OAAA,GAAU,OAAA;EACzE,IAAA;EACA,YAAA,EAAc,YAAA;EACd,KAAA,EAAO,kBAAA;EACP,KAAA,EAAO,UAAA,CAAW,MAAA;EAClB,QAAA,EAAU,6BAAA;IAAkC,QAAA,EAAU,YAAA;EAAA;AAAA;;;;;;;;;;;cAa3C,kBAAA,gBAAkC,OAAA,GAAU,OAAA;EAAA,QAC/C,KAAA;EAAA,QACA,MAAA;EAAA,QACA,aAAA;EAAA,QACA,UAAA;EAAA,QACA,MAAA;cAEI,OAAA,EAAS,mBAAA,CAAoB,MAAA;EApB/B;EAAA,IA6BN,KAAA,CAAA,GAAS,MAAA;EA7ByC;;;AAaxD;EAwBE,MAAA,sBAA4B,MAAA,GAAS,MAAA,yCAAA,CACnC,OAAA,EAAS,yBAAA,CAA0B,YAAA,EAAc,MAAA,EAAQ,cAAA,IACxD,OAAA,CAAQ,wBAAA,CAAyB,YAAA,EAAc,MAAA;EA1BrB;;;;;;;;;;;;;;;;;;;;EAkDvB,QAAA,CAAA;IAAW,MAAA;IAAQ;EAAA;IAAc,MAAA;IAAgB,QAAA,GAAW,aAAA,CAAc,MAAA,IAAU,KAAA,CAAM,aAAA,CAAc,MAAA;EAAA,IAAa,OAAA,CAAQ,gCAAA,CAAiC,MAAA;AAAA;;;;;;;KAoC1J,+BAAA,GACV,IAAA,CAAK,mBAAA;EACH,KAAA,WAAgB,uBAAA,UAAiC,OAAA,CAAQ,uBAAA;EArFnD;;;;EA0FN,KAAA;EACA,MAAA,GAAS,gBAAA,GAAmB,gBAAA;EAC5B,eAAA,GAAkB,cAAA;EAClB,YAAA;EACA,sBAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAXJ;;;;;;;;;;;;;;;iBA4DgB,wBAAA,CAAA;EACd,KAAA;EACA,KAAA;EACA,MAAA;EACA,eAAA;EACA,YAAA;EACA,sBAAA;EAAA,GACG;AAAA,GACF,+BAAA,GAA+B,kBAAA,CAAA,OAAA;iBAAA,EAAA,CAAA,IAAA"}

package/dist/workflow.mjs

@@ -4,16 +4,94 @@ import { DurableAgent } from "@workflow/ai/agent";
 
 //#region src/workflow.ts
 /**
+* A wrapper around the Workflow SDK's `DurableAgent` that adds a non-streaming
+* `.generate()` method alongside the existing `.stream()`.
+*
+* - `.stream()` — delegates to `DurableAgent.stream()`, each tool call is
+*   an individually retriable workflow step. Works in workflow context.
+* - `.generate()` — uses `generateText` from the AI SDK for non-streaming
+*   execution. Must be called from within a `"use step"` function in
+*   workflow context (the Workflow runtime blocks raw I/O in workflow scope).
+*/
+var DurableGithubAgent = class {
+	agent;
+	_model;
+	_instructions;
+	_telemetry;
+	_tools;
+	constructor(options) {
+		this.agent = new DurableAgent(options);
+		this._model = options.model;
+		this._instructions = options.instructions;
+		this._telemetry = options.experimental_telemetry;
+		this._tools = options.tools ?? {};
+	}
+	/** The tool set configured for this agent. */
+	get tools() {
+		return this.agent.tools;
+	}
+	/**
+	* Stream the agent's response. Delegates directly to `DurableAgent.stream()`.
+	* Works in workflow context — each tool call is a durable step.
+	*/
+	stream(options) {
+		return this.agent.stream(options);
+	}
+	/**
+	* Generate a non-streaming response using `generateText` from the AI SDK.
+	*
+	* In workflow context this **must** be called from within a `"use step"`
+	* function, because the Workflow runtime blocks direct I/O (HTTP calls)
+	* at the workflow scope level.
+	*
+	* @example
+	* ```ts
+	* async function agentTurn(prompt: string) {
+	*   "use step"
+	*   const agent = createDurableGithubAgent({
+	*     model: 'anthropic/claude-sonnet-4.6',
+	*     preset: 'code-review',
+	*   })
+	*   const { text } = await agent.generate({ prompt })
+	*   return text
+	* }
+	* ```
+	*/
+	async generate({ prompt, stopWhen }) {
+		const { generateText } = await import("ai");
+		const model = typeof this._model === "function" ? await this._model() : this._model;
+		const system = typeof this._instructions === "string" ? this._instructions : void 0;
+		const result = await generateText({
+			model,
+			tools: this._tools,
+			system,
+			prompt,
+			stopWhen,
+			experimental_telemetry: this._telemetry
+		});
+		return {
+			text: result.text,
+			finishReason: result.finishReason,
+			usage: result.usage,
+			steps: result.steps,
+			response: result.response
+		};
+	}
+};
+/**
 * Create a pre-configured durable GitHub agent powered by Vercel Workflow SDK's `DurableAgent`.
 *
-* Each tool call runs as a durable step with automatic retries and observability.
-* Must be used inside a `"use workflow"` function.
+* Returns a {@link DurableGithubAgent} with two interaction modes:
+*
+* - `.stream()` — works directly in workflow scope; each tool call is a durable step.
+* - `.generate()` — uses `generateText` from the AI SDK; must be called from
+*   within a `"use step"` function when running inside a workflow.
 *
 * **Note:** `requireApproval` is accepted for forward-compatibility but is currently
 * ignored by `DurableAgent` — the Workflow SDK does not yet support interactive tool
 * approval. All tools execute immediately without user confirmation.
 *
-* @example
+* @example Streaming (chat UI — works in workflow scope)
 * ```ts
 * import { createDurableGithubAgent } from '@github-tools/sdk/workflow'
 * import { getWritable } from 'workflow'
@@ -30,6 +108,21 @@ import { DurableAgent } from "@workflow/ai/agent";
 *   await agent.stream({ messages, writable })
 * }
 * ```
+*
+* @example Non-streaming (bot / background job — needs "use step")
+* ```ts
+* import { createDurableGithubAgent } from '@github-tools/sdk/workflow'
+*
+* async function agentTurn(prompt: string) {
+*   "use step"
+*   const agent = createDurableGithubAgent({
+*     model: 'anthropic/claude-sonnet-4.6',
+*     preset: 'code-review',
+*   })
+*   const { text } = await agent.generate({ prompt })
+*   return text
+* }
+* ```
 */
 function createDurableGithubAgent({ model, token, preset, requireApproval, instructions, additionalInstructions, ...agentOptions }) {
 	const tools = createGithubTools({
@@ -38,7 +131,7 @@ function createDurableGithubAgent({ model, token, preset, requireApproval, instr
 		preset
 	});
 	const resolvedModel = typeof model === "string" || typeof model === "function" ? model : () => Promise.resolve(model);
-	return new DurableAgent({
+	return new DurableGithubAgent({
 		...agentOptions,
 		model: resolvedModel,
 		tools,
@@ -51,5 +144,5 @@ function createDurableGithubAgent({ model, token, preset, requireApproval, instr
 }
 
 //#endregion
-export { createDurableGithubAgent, createGithubAgent, createGithubTools };
+export { DurableGithubAgent, createDurableGithubAgent, createGithubAgent, createGithubTools };
 //# sourceMappingURL=workflow.mjs.map

package/dist/workflow.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"workflow.mjs","names":[],"sources":["../src/workflow.ts"],"sourcesContent":["import { DurableAgent } from '@workflow/ai/agent'\nimport type { CompatibleLanguageModel } from '@workflow/ai/agent'\nimport { createGithubTools } from './index'\nimport { resolveInstructions } from './agents'\nimport type { GithubToolPreset, ApprovalConfig } from './index'\n\nexport type CreateDurableGithubAgentOptions = {\n  model: string | CompatibleLanguageModel | (() => Promise<CompatibleLanguageModel>)\n  /**\n   * GitHub personal access token.\n   * Falls back to `process.env.GITHUB_TOKEN` when omitted.\n   */\n  token?: string\n  preset?: GithubToolPreset | GithubToolPreset[]\n  requireApproval?: ApprovalConfig\n  instructions?: string\n  additionalInstructions?: string\n  /** Maximum number of LLM calls before stopping. Unlimited by default. */\n  maxSteps?: number\n  temperature?: number\n}\n\n/**\n * Create a pre-configured durable GitHub agent powered by Vercel Workflow SDK's `DurableAgent`.\n *\n * Each tool call runs as a durable step with automatic retries and observability.\n * Must be used inside a `\"use workflow\"` function.\n *\n * **Note:** `requireApproval` is accepted for forward-compatibility but is currently\n * ignored by `DurableAgent` — the Workflow SDK does not yet support interactive tool\n * approval. All tools execute immediately without user confirmation.\n *\n * @example\n * ```ts\n * import { createDurableGithubAgent } from '@github-tools/sdk/workflow'\n * import { getWritable } from 'workflow'\n * import type { ModelMessage, UIMessageChunk } from 'ai'\n *\n * async function chatWorkflow(messages: ModelMessage[], token: string) {\n *   \"use workflow\"\n *   const agent = createDurableGithubAgent({\n *     model: 'anthropic/claude-sonnet-4.6',\n *     token,\n *     preset: 'code-review',\n *   })\n *   const writable = getWritable<UIMessageChunk>()\n *   await agent.stream({ messages, writable })\n * }\n * ```\n */\nexport function createDurableGithubAgent({\n  model,\n  token,\n  preset,\n  requireApproval,\n  instructions,\n  additionalInstructions,\n  ...agentOptions\n}: CreateDurableGithubAgentOptions) {\n  const tools = createGithubTools({ token, requireApproval, preset })\n\n  const resolvedModel = typeof model === 'string' || typeof model === 'function'\n    ? model\n    : () => Promise.resolve(model)\n\n  return new DurableAgent({\n    ...agentOptions,\n    model: resolvedModel,\n    tools,\n    instructions: resolveInstructions({ preset, instructions, additionalInstructions }),\n  })\n}\n\nexport { createGithubTools, createGithubAgent } from './index'\nexport type { GithubTools, GithubToolsOptions, GithubToolPreset, GithubWriteToolName, ApprovalConfig } from './index'\nexport type { CreateGithubAgentOptions } from './agents'\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,SAAgB,yBAAyB,EACvC,OACA,OACA,QACA,iBACA,cACA,wBACA,GAAG,gBAC+B;CAClC,MAAM,QAAQ,kBAAkB;EAAE;EAAO;EAAiB;EAAQ,CAAC;CAEnE,MAAM,gBAAgB,OAAO,UAAU,YAAY,OAAO,UAAU,aAChE,cACM,QAAQ,QAAQ,MAAM;AAEhC,QAAO,IAAI,aAAa;EACtB,GAAG;EACH,OAAO;EACP;EACA,cAAc,oBAAoB;GAAE;GAAQ;GAAc;GAAwB,CAAC;EACpF,CAAC"}
+{"version":3,"file":"workflow.mjs","names":[],"sources":["../src/workflow.ts"],"sourcesContent":["import { DurableAgent } from '@workflow/ai/agent'\nimport type { CompatibleLanguageModel, DurableAgentOptions, DurableAgentStreamOptions, DurableAgentStreamResult, TelemetrySettings } from '@workflow/ai/agent'\nimport type { ToolSet, StepResult, FinishReason, LanguageModelUsage, LanguageModelResponseMetadata, ModelMessage, StopCondition } from 'ai'\nimport { createGithubTools } from './index'\nimport { resolveInstructions } from './agents'\nimport type { GithubToolPreset, ApprovalConfig } from './index'\n\n/**\n * Result of {@link DurableGithubAgent.generate}.\n */\nexport interface DurableGithubAgentGenerateResult<TTools extends ToolSet = ToolSet> {\n  text: string\n  finishReason: FinishReason\n  usage: LanguageModelUsage\n  steps: StepResult<TTools>[]\n  response: LanguageModelResponseMetadata & { messages: ModelMessage[] }\n}\n\n/**\n * A wrapper around the Workflow SDK's `DurableAgent` that adds a non-streaming\n * `.generate()` method alongside the existing `.stream()`.\n *\n * - `.stream()` — delegates to `DurableAgent.stream()`, each tool call is\n *   an individually retriable workflow step. Works in workflow context.\n * - `.generate()` — uses `generateText` from the AI SDK for non-streaming\n *   execution. Must be called from within a `\"use step\"` function in\n *   workflow context (the Workflow runtime blocks raw I/O in workflow scope).\n */\nexport class DurableGithubAgent<TTools extends ToolSet = ToolSet> {\n  private agent: DurableAgent<TTools>\n  private _model: DurableAgentOptions<TTools>['model']\n  private _instructions?: DurableAgentOptions<TTools>['instructions']\n  private _telemetry?: TelemetrySettings\n  private _tools: TTools\n\n  constructor(options: DurableAgentOptions<TTools>) {\n    this.agent = new DurableAgent(options)\n    this._model = options.model\n    this._instructions = options.instructions\n    this._telemetry = options.experimental_telemetry\n    this._tools = options.tools ?? {} as TTools\n  }\n\n  /** The tool set configured for this agent. */\n  get tools(): TTools {\n    return this.agent.tools\n  }\n\n  /**\n   * Stream the agent's response. Delegates directly to `DurableAgent.stream()`.\n   * Works in workflow context — each tool call is a durable step.\n   */\n  stream<TStreamTools extends TTools = TTools, OUTPUT = never, PARTIAL_OUTPUT = never>(\n    options: DurableAgentStreamOptions<TStreamTools, OUTPUT, PARTIAL_OUTPUT>,\n  ): Promise<DurableAgentStreamResult<TStreamTools, OUTPUT>> {\n    return this.agent.stream(options)\n  }\n\n  /**\n   * Generate a non-streaming response using `generateText` from the AI SDK.\n   *\n   * In workflow context this **must** be called from within a `\"use step\"`\n   * function, because the Workflow runtime blocks direct I/O (HTTP calls)\n   * at the workflow scope level.\n   *\n   * @example\n   * ```ts\n   * async function agentTurn(prompt: string) {\n   *   \"use step\"\n   *   const agent = createDurableGithubAgent({\n   *     model: 'anthropic/claude-sonnet-4.6',\n   *     preset: 'code-review',\n   *   })\n   *   const { text } = await agent.generate({ prompt })\n   *   return text\n   * }\n   * ```\n   */\n  async generate({ prompt, stopWhen }: { prompt: string, stopWhen?: StopCondition<TTools> | Array<StopCondition<TTools>> }): Promise<DurableGithubAgentGenerateResult<TTools>> {\n    const { generateText } = await import('ai')\n\n    const model = typeof this._model === 'function'\n      ? await this._model()\n      : this._model\n\n    const system = typeof this._instructions === 'string'\n      ? this._instructions\n      : undefined\n\n    const result = await generateText({\n      model: model as Parameters<typeof generateText>[0]['model'],\n      tools: this._tools,\n      system,\n      prompt,\n      stopWhen,\n      experimental_telemetry: this._telemetry as Parameters<typeof generateText>[0]['experimental_telemetry'],\n    })\n\n    return {\n      text: result.text,\n      finishReason: result.finishReason,\n      usage: result.usage,\n      steps: result.steps as StepResult<TTools>[],\n      response: result.response,\n    }\n  }\n}\n\n/**\n * Options for creating a durable GitHub agent via {@link createDurableGithubAgent}.\n *\n * Extends all `DurableAgentOptions` (temperature, telemetry, callbacks, etc.)\n * and adds GitHub-specific fields (token, preset, approval config).\n */\nexport type CreateDurableGithubAgentOptions =\n  Omit<DurableAgentOptions, 'model' | 'tools' | 'instructions'> & {\n    model: string | CompatibleLanguageModel | (() => Promise<CompatibleLanguageModel>)\n    /**\n     * GitHub personal access token.\n     * Falls back to `process.env.GITHUB_TOKEN` when omitted.\n     */\n    token?: string\n    preset?: GithubToolPreset | GithubToolPreset[]\n    requireApproval?: ApprovalConfig\n    instructions?: string\n    additionalInstructions?: string\n  }\n\n/**\n * Create a pre-configured durable GitHub agent powered by Vercel Workflow SDK's `DurableAgent`.\n *\n * Returns a {@link DurableGithubAgent} with two interaction modes:\n *\n * - `.stream()` — works directly in workflow scope; each tool call is a durable step.\n * - `.generate()` — uses `generateText` from the AI SDK; must be called from\n *   within a `\"use step\"` function when running inside a workflow.\n *\n * **Note:** `requireApproval` is accepted for forward-compatibility but is currently\n * ignored by `DurableAgent` — the Workflow SDK does not yet support interactive tool\n * approval. All tools execute immediately without user confirmation.\n *\n * @example Streaming (chat UI — works in workflow scope)\n * ```ts\n * import { createDurableGithubAgent } from '@github-tools/sdk/workflow'\n * import { getWritable } from 'workflow'\n * import type { ModelMessage, UIMessageChunk } from 'ai'\n *\n * async function chatWorkflow(messages: ModelMessage[], token: string) {\n *   \"use workflow\"\n *   const agent = createDurableGithubAgent({\n *     model: 'anthropic/claude-sonnet-4.6',\n *     token,\n *     preset: 'code-review',\n *   })\n *   const writable = getWritable<UIMessageChunk>()\n *   await agent.stream({ messages, writable })\n * }\n * ```\n *\n * @example Non-streaming (bot / background job — needs \"use step\")\n * ```ts\n * import { createDurableGithubAgent } from '@github-tools/sdk/workflow'\n *\n * async function agentTurn(prompt: string) {\n *   \"use step\"\n *   const agent = createDurableGithubAgent({\n *     model: 'anthropic/claude-sonnet-4.6',\n *     preset: 'code-review',\n *   })\n *   const { text } = await agent.generate({ prompt })\n *   return text\n * }\n * ```\n */\nexport function createDurableGithubAgent({\n  model,\n  token,\n  preset,\n  requireApproval,\n  instructions,\n  additionalInstructions,\n  ...agentOptions\n}: CreateDurableGithubAgentOptions) {\n  const tools = createGithubTools({ token, requireApproval, preset })\n\n  const resolvedModel = typeof model === 'string' || typeof model === 'function'\n    ? model\n    : () => Promise.resolve(model)\n\n  return new DurableGithubAgent({\n    ...agentOptions as Omit<typeof agentOptions, 'toolChoice'>,\n    model: resolvedModel,\n    tools,\n    instructions: resolveInstructions({ preset, instructions, additionalInstructions }),\n  })\n}\n\nexport { createGithubTools, createGithubAgent } from './index'\nexport type { GithubTools, GithubToolsOptions, GithubToolPreset, GithubWriteToolName, ApprovalConfig, ToolOverrides } from './index'\nexport type { CreateGithubAgentOptions } from './agents'\n"],"mappings":";;;;;;;;;;;;;;;AA4BA,IAAa,qBAAb,MAAkE;CAChE,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CAER,YAAY,SAAsC;AAChD,OAAK,QAAQ,IAAI,aAAa,QAAQ;AACtC,OAAK,SAAS,QAAQ;AACtB,OAAK,gBAAgB,QAAQ;AAC7B,OAAK,aAAa,QAAQ;AAC1B,OAAK,SAAS,QAAQ,SAAS,EAAE;;;CAInC,IAAI,QAAgB;AAClB,SAAO,KAAK,MAAM;;;;;;CAOpB,OACE,SACyD;AACzD,SAAO,KAAK,MAAM,OAAO,QAAQ;;;;;;;;;;;;;;;;;;;;;;CAuBnC,MAAM,SAAS,EAAE,QAAQ,YAAoJ;EAC3K,MAAM,EAAE,iBAAiB,MAAM,OAAO;EAEtC,MAAM,QAAQ,OAAO,KAAK,WAAW,aACjC,MAAM,KAAK,QAAQ,GACnB,KAAK;EAET,MAAM,SAAS,OAAO,KAAK,kBAAkB,WACzC,KAAK,gBACL;EAEJ,MAAM,SAAS,MAAM,aAAa;GACzB;GACP,OAAO,KAAK;GACZ;GACA;GACA;GACA,wBAAwB,KAAK;GAC9B,CAAC;AAEF,SAAO;GACL,MAAM,OAAO;GACb,cAAc,OAAO;GACrB,OAAO,OAAO;GACd,OAAO,OAAO;GACd,UAAU,OAAO;GAClB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsEL,SAAgB,yBAAyB,EACvC,OACA,OACA,QACA,iBACA,cACA,wBACA,GAAG,gBAC+B;CAClC,MAAM,QAAQ,kBAAkB;EAAE;EAAO;EAAiB;EAAQ,CAAC;CAEnE,MAAM,gBAAgB,OAAO,UAAU,YAAY,OAAO,UAAU,aAChE,cACM,QAAQ,QAAQ,MAAM;AAEhC,QAAO,IAAI,mBAAmB;EAC5B,GAAG;EACH,OAAO;EACP;EACA,cAAc,oBAAoB;GAAE;GAAQ;GAAc;GAAwB,CAAC;EACpF,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@github-tools/sdk",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "GitHub tools for the Vercel AI SDK, wrap GitHub's API as AI SDK tools ready to plug into any agent",
   "author": "HugoRCD <hugo.richard@vercel.com",
   "repository": {