@msg91comm/m91 1.1.0 → 1.2.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 1.2.0
+
+### Added
+- **OpenAI Agents SDK** (`@msg91comm/m91/integrations/openai-agents`): `runWithM91Approvals` answers every `needsApproval` interruption on a phone and resumes the run; `approveInterruptionsWithM91` for your own loop; `createM91Tools`.
+- **Claude Agent SDK** (`@msg91comm/m91/integrations/claude-agent-sdk`): `createM91CanUseTool` (a `canUseTool` callback), `createM91PreToolUseHook` (gates in every permission mode), and `createM91McpServer` (the two tools as an in-process MCP server).
+- **Google ADK for TypeScript** (`@msg91comm/m91/integrations/google-adk`): `createM91BeforeToolCallback` gates named tools; `createM91Tools` as `FunctionTool`s.
+- **Mastra** (`@msg91comm/m91/integrations/mastra`): `generateWithM91Approvals` answers `requireApproval` suspensions; `createM91Tools`.
+- **Vercel AI SDK**: `createM91ToolApproval`, a `toolApproval` function that rings a phone before the tools you name run.
+- **LangChain `humanInTheLoopMiddleware` and Deep Agents** (`@msg91comm/m91/integrations/langchain`): `invokeWithM91Approvals` answers each `interruptOn` pause on a phone and resumes with `Command({ resume: { decisions } })`; `resolveHITLWithM91` builds the decisions for your own loop.
+- `decideToolCall`, `GateOptions`: the shared fail-closed gate every adapter above uses.
+
+### Fixed
+- Vercel AI SDK tool factories return `Tool` / `ToolSet`, and LangChain's return `DynamicStructuredTool`, instead of `unknown`, so they type-check in `generateText({ tools })` and `createAgent({ tools })`. Runtime behaviour is unchanged.
+- The `ai` peer range is `>=5.0.0`, matching the `inputSchema` tool format.
+- Docs and docstrings use the published package name (`@msg91comm/m91`) and current APIs (`createAgent`, `isStepCount`).
+
+## Fixed
+- `@msg91comm/m91/integrations/vercel-ai`: `createM91ApprovalTool`, `createM91AlertTool` and `createM91Tools` are now typed as the AI SDK's `Tool` / `ToolSet` instead of `unknown`, so they type-check inside `generateText({ tools })`. Runtime behaviour is unchanged.
+- The `ai` peer dependency range is now `>=5.0.0`, matching the `inputSchema` tool format these factories use.
+
+## 1.1.1
+
+Metadata only — no code change.
+
+`homepage` pointed at `https://m91.msg91.com`, which does not resolve: that
+host is the static site, and every backend route lives on `m91-api.msg91.com`.
+npm renders `homepage` as a link on the package page and freezes it per
+version, so 1.1.0's link is dead for the life of that version. It now points at
+the documentation.
+
+The package also went out as `@msg91comm/m91` while the repository still said
+`"name": "m91"`, so the next publish would have gone to a different package.
+The repository now matches what is published.
+
+
 ## 1.1.0
 
 Three gaps where the server had grown a field and the SDK had not, so the only

package/README.md

@@ -28,13 +28,17 @@ dependencies, imported only when you call one:
 | `@msg91comm/m91` — client, platform, URL builder | nothing |
 | `@msg91comm/m91/integrations/langchain` | `@langchain/core` |
 | `@msg91comm/m91/integrations/langgraph` | nothing — it wraps the client, not the graph |
-| `@msg91comm/m91/integrations/vercel-ai` | `ai` |
+| `@msg91comm/m91/integrations/vercel-ai` | `ai` (v5 or later) |
+| `@msg91comm/m91/integrations/openai-agents` | `@openai/agents` |
+| `@msg91comm/m91/integrations/claude-agent-sdk` | `@anthropic-ai/claude-agent-sdk`, `zod` |
+| `@msg91comm/m91/integrations/google-adk` | `@google/adk`, `zod` |
+| `@msg91comm/m91/integrations/mastra` | `@mastra/core`, `zod` |
 
 ---
 
 ## Quick start
 
-You need a **send link** — `https://m91.msg91.com/s/<token>` — from the channel
+You need a **send link** — `https://m91-api.msg91.com/s/<token>` — from the channel
 in the M91 app. The token is in the URL path, so the link *is* the credential:
 keep it in the environment, never in the repository.
 
@@ -79,6 +83,58 @@ only when somebody tapped **Approve**. A rejection, a timeout and an unreachable
 channel all resolve `false` or throw — there is no configuration under which
 silence means yes.
 
+### Asking for a reason, not just a tap
+
+An option can require something before it can be chosen. `required` blocks the
+button until it is supplied; `optional` offers a skippable field.
+
+```ts
+await client.send('Agent wants to refund ₹48,000 on order ORD-40122', {
+  customId: 'refund-ORD-40122',
+  responseOptions: [
+    { label: 'Approve', effect: 'SHARED' },
+    { label: 'Reject',  effect: 'SHARED', required: ['note'] },
+    { label: 'Need the delivery photo', effect: 'SHARED', optional: ['attachment'] },
+  ],
+});
+```
+
+Only two things can be asked for: `'note'` and `'attachment'`. Requiring a note
+on the rejection is the difference between your code learning *no* and learning
+*why* — worth it on any branch that has to explain itself to a customer later.
+
+Two more fields on `send`:
+
+- **`attachments`** — https links to files the alert is about, shown on the
+  alert screen. URLs, never bytes.
+- **`other`** — whether the free-text "Something else" reply is offered. Leave
+  it unset and the server's default (on) stands; set `false` when the answer
+  must be one of your options.
+
+### `callbackUrl` instead of polling
+
+`waitForDecision` and `requestApproval` poll. For a service that is already
+listening on a URL, hand M91 the URL instead and the outcome is POSTed to it
+when somebody answers:
+
+```ts
+await client.send('Agent wants to refund ₹48,000 on order ORD-40122', {
+  customId: 'refund-ORD-40122',
+  callbackUrl: 'https://your-service.example.com/hooks/m91',
+  responseOptions: [{ label: 'Approve', effect: 'SHARED' },
+                    { label: 'Reject',  effect: 'SHARED', required: ['note'] }],
+});
+```
+
+**It will not reach your laptop.** The callback is fetched by M91's servers and
+private addresses are refused — `localhost`, `127.0.0.1`, `10.x`, `192.168.x`
+and the rest — so local development and anything inside a VPC has to poll. Use
+a tunnel, or keep `waitForDecision` for development and the callback in
+production.
+
+You still own the timeout either way. There is no server-side expiry: decide
+what silence means before you send, and make it the safe answer.
+
 ---
 
 ## Severity
@@ -112,7 +168,7 @@ console.log(builder.build('CPU above 95% on prod-server-3', {
   customId: 'cpu-high-prod3',
   respond: ['On it', 'Escalate'],
 }));
-// https://m91.msg91.com/s/TOKEN?title=CPU+above+95%25+on+prod-server-3&severity=HIGH
+// https://m91-api.msg91.com/s/TOKEN?title=CPU+above+95%25+on+prod-server-3&severity=HIGH
 //   &customId=cpu-high-prod3&respond=On+it%2CEscalate
 ```
 
@@ -173,12 +229,20 @@ stale device token is the difference between waking somebody and waking nobody.
 
 The cases an API key exists for — per-user alerting, per-tenant channels, roster
 sync — and the much larger set where a send link is the right answer, are worked
-through at **<https://m91.msg91.com/docs>**.
+through at **<https://m91-api.msg91.com/docs>**.
 
 ---
 
 ## LangChain
 
+An agent that must not act alone needs a human, and the hard part is not pausing
+— it is **reaching somebody**. `interrupt()` stops the graph and waits for a
+resume that only arrives if a person happens to be watching a dashboard. M91
+fills that half: the tool call rings every phone on a channel at full volume,
+through silent mode and Do Not Disturb, escalating to a voice call if nobody
+answers. The tool returns `"approved"` only when a human tapped **Approve**;
+a rejection, a timeout and an unreachable channel are all a no.
+
 ```ts
 import { M91Client } from '@msg91comm/m91';
 import { createM91ApprovalTool, createM91AlertTool } from '@msg91comm/m91/integrations/langchain';
@@ -190,7 +254,7 @@ const tools = [
   await createM91AlertTool(client),     // wakes somebody, carries on
   ...myTools,
 ];
-const agent = createReactAgent({ llm, tools, prompt: SYSTEM });
+const agent = createAgent({ model: 'openai:gpt-5-mini', tools, systemPrompt: SYSTEM });  // from 'langchain'
 ```
 
 The factories are async because `@langchain/core` is imported only when you call
@@ -218,6 +282,37 @@ await createM91ApprovalTool(client, {
 
 ---
 
+### `humanInTheLoopMiddleware` and Deep Agents
+
+LangChain's `humanInTheLoopMiddleware` (and Deep Agents' `interruptOn`, which is
+built on it) pauses the run before the tools you name and waits for
+`{ decisions: [...] }`. `invokeWithM91Approvals` answers each pause on a phone
+and resumes the same thread:
+
+```ts
+import { createDeepAgent } from 'deepagents';
+import { MemorySaver } from '@langchain/langgraph';
+import { invokeWithM91Approvals } from '@msg91comm/m91/integrations/langchain';
+
+const agent = createDeepAgent({
+  interruptOn: { write_file: true, edit_file: true, execute: true },
+  checkpointer: new MemorySaver(),
+});
+
+const result = await invokeWithM91Approvals(
+  agent,
+  { messages: [{ role: 'user', content: 'Write the release notes to RELEASE.md.' }] },
+  { configurable: { thread_id: 'release-v2.4' } },
+  client,
+);
+```
+
+The same call works for `createAgent({ middleware: [humanInTheLoopMiddleware({ interruptOn })] })`.
+Running your own loop? `resolveHITLWithM91(result.__interrupt__[0].value, client)`
+returns the `{ decisions }` to pass to `new Command({ resume })`.
+
+---
+
 ## LangGraph
 
 LangGraph knows how to stop a graph and resume it. What it has no opinion about
@@ -255,22 +350,146 @@ The node reads `title` (or `question`) and `customId` from state, and writes
 
 ## Vercel AI SDK
 
+Two ways in. **Tools** the model calls when it decides to ask:
+
 ```ts
-import { createM91ApprovalTool, createM91AlertTool } from '@msg91comm/m91/integrations/vercel-ai';
+import { generateText, isStepCount } from 'ai';
+import { createM91Tools } from '@msg91comm/m91/integrations/vercel-ai';
 
 const { text } = await generateText({
-  model: openai('gpt-4o'),
-  tools: {
-    m91_request_approval: await createM91ApprovalTool(client),
-    m91_send_alert: await createM91AlertTool(client),
-  },
-  stopWhen: stepCountIs(10),
+  model: 'openai/gpt-5-mini',
+  tools: { ...(await createM91Tools(client)) },
+  stopWhen: isStepCount(10),
   prompt: 'Verify the GDPR deletion request for acct_8821 and action it.',
 });
 ```
 
+**A gate** on your own tools, through the AI SDK's `toolApproval` option. The
+named tools ring a phone before they run; the model cannot skip it.
+
+```ts
+import { createM91ToolApproval } from '@msg91comm/m91/integrations/vercel-ai';
+
+await generateText({
+  model: 'openai/gpt-5-mini',
+  tools: { issueRefund, deleteUser },
+  toolApproval: createM91ToolApproval(client, { tools: ['issueRefund', 'deleteUser'] }),
+  stopWhen: isStepCount(10),
+  prompt: 'Refund ORD-40122.',
+});
+```
+
 ---
 
+## OpenAI Agents SDK
+
+Mark risky tools `needsApproval: true`. `runWithM91Approvals` answers every
+pause on a phone and resumes the same run.
+
+```ts
+import { Agent, tool } from '@openai/agents';
+import { runWithM91Approvals } from '@msg91comm/m91/integrations/openai-agents';
+
+const issueRefund = tool({
+  name: 'issue_refund',
+  description: 'Refund an order.',
+  parameters: z.object({ orderId: z.string(), amount: z.number() }),
+  needsApproval: true,
+  execute: async ({ orderId, amount }) => refunds.create(orderId, amount),
+});
+
+const agent = new Agent({ name: 'Support', instructions: 'Resolve refund requests.', tools: [issueRefund] });
+const result = await runWithM91Approvals(agent, 'Refund ORD-40122, it never arrived.', client);
+console.log(result.finalOutput);
+```
+
+Running your own loop? `approveInterruptionsWithM91(result, client)` decides the
+pending approvals on `result.state`; then call `run(agent, result.state)`.
+`createM91Tools(client)` gives the agent the two tools as well.
+
+---
+
+## Claude Agent SDK
+
+```ts
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { createM91CanUseTool, createM91McpServer } from '@msg91comm/m91/integrations/claude-agent-sdk';
+
+for await (const message of query({
+  prompt: 'Delete the stale feature branches and deploy main.',
+  options: {
+    // Bash and Write ring a phone first; every other tool runs as normal.
+    canUseTool: createM91CanUseTool(client, { tools: ['Bash', 'Write'] }),
+    // Optional: let Claude decide to ask, or to wake somebody.
+    mcpServers: { m91: await createM91McpServer(client) },
+  },
+})) {
+  if (message.type === 'result') console.log(message);
+}
+```
+
+`canUseTool` only runs when the SDK would otherwise ask. To gate a tool in every
+permission mode, including `bypassPermissions`, pass
+`hooks: { PreToolUse: createM91PreToolUseHook(client, { tools: ['Bash'] }) }`.
+
+---
+
+## Google ADK
+
+```ts
+import { LlmAgent } from '@google/adk';
+import { createM91BeforeToolCallback, createM91Tools } from '@msg91comm/m91/integrations/google-adk';
+
+const agent = new LlmAgent({
+  name: 'support_agent',
+  model: 'gemini-2.5-flash',
+  instruction: 'Resolve refund requests.',
+  tools: [issueRefund, ...(await createM91Tools(client))],
+  // issue_refund rings a phone first. A rejection skips the tool and tells the agent why.
+  beforeToolCallback: createM91BeforeToolCallback(client, { tools: ['issue_refund'] }),
+});
+```
+
+---
+
+## Mastra
+
+```ts
+import { Agent } from '@mastra/core/agent';
+import { createTool } from '@mastra/core/tools';
+import { generateWithM91Approvals } from '@msg91comm/m91/integrations/mastra';
+
+const issueRefund = createTool({
+  id: 'issue-refund',
+  description: 'Refund an order.',
+  inputSchema: z.object({ orderId: z.string(), amount: z.number() }),
+  requireApproval: true,
+  execute: async ({ orderId, amount }) => refunds.create(orderId, amount),
+});
+
+const agent = new Agent({
+  id: 'support', name: 'Support', instructions: 'Resolve refund requests.',
+  model: 'openai/gpt-5-mini', tools: { issueRefund },
+});
+
+const output = await generateWithM91Approvals(agent, 'Refund ORD-40122.', client);
+console.log(output.text);
+```
+
+Mastra keeps suspended runs in storage, so configure a storage provider on your
+`Mastra` instance.
+
+---
+
+### Which tools ring a phone
+
+Every gate takes `tools`: a list of tool names, or a predicate
+(`(name, input) => boolean`). Gates fail closed: a rejection, no answer within
+`timeoutSeconds` (default 300) or an M91 error means the tool does not run, and
+the agent is told why. Write the lock-screen text yourself with
+`describe: (call) => ({ title, description })`.
+
+---
 
 ## Error handling
 
@@ -361,7 +580,7 @@ alert, and repeating it is how one condition wakes a team four times.
 | `close({ customId? , alertId? }): Promise<boolean>` | Close it. Exactly one id. |
 | `requestApproval(title, options): Promise<boolean>` | Send, wait, close. |
 
-`SendOptions`: `{ description?, severity?, customId?, isAutoClose?, responseOptions? }`
+`SendOptions`: `{ description?, severity?, customId?, isAutoClose?, responseOptions?, other?, attachments?, callbackUrl? }`
 `WaitOptions`: `{ timeoutMs?, pollIntervalMs?, throwOnTimeout? }`
 `ApprovalOptions`: `{ customId, description?, severity?, approveLabel?, rejectLabel?, timeoutMs?, pollIntervalMs?, timeoutMeansReject? }`
 
@@ -375,6 +594,7 @@ alert, and repeating it is how one condition wakes a team four times.
 | `alertPerson(phone, title, options?): Promise<AlertResponse>` | Wake one person. |
 | `getAlert(alertId, phone): Promise<AlertDetail \| null>` | Read what they decided. |
 | `closeAlert(phone, { customId? , alertId? }): Promise<boolean>` | Close their alert. |
+| `listChannels(): Promise<ProvisionedChannel[]>` | Every channel this key owns. |
 | `createChannel(name, alertOwner?): Promise<ProvisionedChannel>` | **Not idempotent.** Store the result. |
 | `addMembers(channelId, phones): Promise<InviteResult>` | Up to 500 per call. |
 | `removeMember(channelId, phone): Promise<boolean>` | Take them off the roster. |
@@ -390,7 +610,7 @@ alert, and repeating it is how one condition wakes a team four times.
 ### Types
 
 `Severity` · `Effect` · `AlertStatus` · `RecipientState` · `ResponseOption` ·
-`Decision` · `AlertResponse` · `AlertDetail` · `ChannelInfo` · `Recipient` ·
+`Collectable` · `Attachment` · `Decision` · `AlertResponse` · `AlertDetail` · `ChannelInfo` · `Recipient` ·
 `ProvisionedChannel` · `InviteResult` · `ApiKeyInfo`
 
 Helpers: `isApproved(decision, approveLabel?)` · `validatePhone(phone)` ·
@@ -408,11 +628,12 @@ Compiles with `tsc` and runs the suite on Node's built-in test runner — no tes
 framework to install. Every test swaps `fetch`; nothing here makes a network
 call, and nothing wakes anybody.
 
-For the SDK against a real socket — a live server, a real poll loop, a real
-timeout — run the demo:
+For the SDK against a real socket — a real send, a real poll loop, a real
+timeout — point an example at your own channel. This wakes a phone:
 
 ```bash
-cd ../demo && python3 run_node_demo.py
+export M91_SEND_LINK='https://m91-api.msg91.com/s/<token>'
+npx tsx examples/basic-alert.ts
 ```
 
 ---
@@ -421,6 +642,7 @@ cd ../demo && python3 run_node_demo.py
 
 The `examples/` directory included with the SDK covers a basic alert, the approval
 gate, a LangChain agent, the LangGraph `interrupt()` pattern, a Vercel AI SDK
-agent, and webhook URLs for Grafana and friends.
+agent, OpenAI Agents, Claude Agent SDK, Google ADK and Mastra agents gated by
+M91, and webhook URLs for Grafana and friends.
 
-Full API documentation: **<https://m91.msg91.com/docs>**
+Full API documentation: **<https://m91-api.msg91.com/docs>**

package/dist/src/index.d.ts

@@ -45,5 +45,5 @@ export type { AlertDetail, AlertResponse, AlertStatus, ApiKeyInfo, ChannelInfo,
  * written twice — and it drifted, reporting 1.0.0 while the package shipped as
  * 1.1.0. A test is what makes two copies safe.
  */
-export declare const VERSION = "1.1.0";
+export declare const VERSION = "1.2.0";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -41,5 +41,5 @@ export { SEVERITIES, EFFECTS, ESCALATING_SEVERITIES, isApproved, validatePhone,
  * written twice — and it drifted, reporting 1.0.0 while the package shipped as
  * 1.1.0. A test is what makes two copies safe.
  */
-export const VERSION = '1.1.0';
+export const VERSION = '1.2.0';
 //# sourceMappingURL=index.js.map

package/dist/src/integrations/claude-agent-sdk.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Claude Agent SDK (`@anthropic-ai/claude-agent-sdk`): M91 as the permission
+ * prompt, and M91 as tools.
+ *
+ * **Permission prompt.** `createM91CanUseTool` is a `canUseTool` callback: the
+ * tools you name ring a phone and run only if a person approves. Everything
+ * else is allowed through untouched.
+ *
+ * ```ts
+ * import { query } from '@anthropic-ai/claude-agent-sdk';
+ * import { M91Client } from '@msg91comm/m91';
+ * import { createM91CanUseTool } from '@msg91comm/m91/integrations/claude-agent-sdk';
+ *
+ * const client = new M91Client(process.env.M91_SEND_LINK!);
+ *
+ * for await (const message of query({
+ *   prompt: 'Clean up the stale feature branches and deploy main.',
+ *   options: { canUseTool: createM91CanUseTool(client, { tools: ['Bash', 'Write'] }) },
+ * })) {
+ *   if (message.type === 'result') console.log(message);
+ * }
+ * ```
+ *
+ * `canUseTool` only runs when the SDK would otherwise ask. To gate a tool
+ * whatever the permission mode (including `bypassPermissions`), use the
+ * `PreToolUse` hook from `createM91PreToolUseHook` instead.
+ *
+ * **Tools.** `createM91McpServer` exposes `m91_request_approval` and
+ * `m91_send_alert` as an in-process MCP server, for when the agent itself
+ * should decide to ask or to wake somebody.
+ */
+import type { CanUseTool, HookCallbackMatcher, McpSdkServerConfigWithInstance } from '@anthropic-ai/claude-agent-sdk';
+import type { M91Client } from '../client.js';
+import { type AlertDefaults, type ApprovalDefaults, type GateOptions } from './specs.js';
+/** Tool names, or a predicate. Required: an agent that rings for every `Read` gets muted. */
+type ClaudeGateOptions = GateOptions & {
+    tools: NonNullable<GateOptions['tools']>;
+};
+/**
+ * A `canUseTool` callback that asks a person on their phone before the tools
+ * in `options.tools` run.
+ */
+export declare function createM91CanUseTool(client: M91Client, options: ClaudeGateOptions): CanUseTool;
+/**
+ * A `PreToolUse` hook matcher that asks a person before the tools in
+ * `options.tools` run, in every permission mode. Pass it as
+ * `options.hooks.PreToolUse`.
+ *
+ * ```ts
+ * query({ prompt, options: { hooks: { PreToolUse: createM91PreToolUseHook(client, { tools: ['Bash'] }) } } })
+ * ```
+ */
+export declare function createM91PreToolUseHook(client: M91Client, options: ClaudeGateOptions & {
+    timeoutSeconds?: number;
+}): HookCallbackMatcher[];
+/**
+ * `m91_request_approval` and `m91_send_alert` as an in-process MCP server.
+ * Register it under `mcpServers.m91`; the tools appear to Claude as
+ * `mcp__m91__m91_request_approval` and `mcp__m91__m91_send_alert`.
+ */
+export declare function createM91McpServer(client: M91Client, defaults?: ApprovalDefaults & AlertDefaults): Promise<McpSdkServerConfigWithInstance>;
+export {};
+//# sourceMappingURL=claude-agent-sdk.d.ts.map

package/dist/src/integrations/claude-agent-sdk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-agent-sdk.d.ts","sourceRoot":"","sources":["../../../src/integrations/claude-agent-sdk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,KAAK,EACV,UAAU,EACV,mBAAmB,EACnB,8BAA8B,EAE/B,MAAM,gCAAgC,CAAC;AAExC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAML,KAAK,aAAa,EAElB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAKjB,MAAM,YAAY,CAAC;AAGpB,6FAA6F;AAC7F,KAAK,iBAAiB,GAAG,WAAW,GAAG;IAAE,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAA;CAAE,CAAC;AAEpF;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,iBAAiB,GAAG,UAAU,CAU7F;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,iBAAiB,GAAG;IAAE,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,GACvD,mBAAmB,EAAE,CAyBvB;AAsBD;;;;GAIG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,gBAAgB,GAAG,aAAkB,GAC9C,OAAO,CAAC,8BAA8B,CAAC,CAczC"}

package/dist/src/integrations/claude-agent-sdk.js

@@ -0,0 +1,109 @@
+/**
+ * Claude Agent SDK (`@anthropic-ai/claude-agent-sdk`): M91 as the permission
+ * prompt, and M91 as tools.
+ *
+ * **Permission prompt.** `createM91CanUseTool` is a `canUseTool` callback: the
+ * tools you name ring a phone and run only if a person approves. Everything
+ * else is allowed through untouched.
+ *
+ * ```ts
+ * import { query } from '@anthropic-ai/claude-agent-sdk';
+ * import { M91Client } from '@msg91comm/m91';
+ * import { createM91CanUseTool } from '@msg91comm/m91/integrations/claude-agent-sdk';
+ *
+ * const client = new M91Client(process.env.M91_SEND_LINK!);
+ *
+ * for await (const message of query({
+ *   prompt: 'Clean up the stale feature branches and deploy main.',
+ *   options: { canUseTool: createM91CanUseTool(client, { tools: ['Bash', 'Write'] }) },
+ * })) {
+ *   if (message.type === 'result') console.log(message);
+ * }
+ * ```
+ *
+ * `canUseTool` only runs when the SDK would otherwise ask. To gate a tool
+ * whatever the permission mode (including `bypassPermissions`), use the
+ * `PreToolUse` hook from `createM91PreToolUseHook` instead.
+ *
+ * **Tools.** `createM91McpServer` exposes `m91_request_approval` and
+ * `m91_send_alert` as an in-process MCP server, for when the agent itself
+ * should decide to ask or to wake somebody.
+ */
+import { ALERT_DESCRIPTION, ALERT_TOOL_NAME, APPROVAL_DESCRIPTION, APPROVAL_TOOL_NAME, decideToolCall, needsHuman, runAlert, runApproval, } from './specs.js';
+import { alertShape, approvalShape, loadZod } from './zod-shapes.js';
+/**
+ * A `canUseTool` callback that asks a person on their phone before the tools
+ * in `options.tools` run.
+ */
+export function createM91CanUseTool(client, options) {
+    return async (toolName, input, { toolUseID }) => {
+        if (!(await needsHuman(options, toolName, input))) {
+            return { behavior: 'allow', updatedInput: input };
+        }
+        const decision = await decideToolCall(client, { toolName, input, callId: toolUseID }, options);
+        return decision.approved
+            ? { behavior: 'allow', updatedInput: input }
+            : { behavior: 'deny', message: decision.reason };
+    };
+}
+/**
+ * A `PreToolUse` hook matcher that asks a person before the tools in
+ * `options.tools` run, in every permission mode. Pass it as
+ * `options.hooks.PreToolUse`.
+ *
+ * ```ts
+ * query({ prompt, options: { hooks: { PreToolUse: createM91PreToolUseHook(client, { tools: ['Bash'] }) } } })
+ * ```
+ */
+export function createM91PreToolUseHook(client, options) {
+    return [
+        {
+            // The hook must outlive the wait for a human, or the SDK gives up first.
+            timeout: (options.timeoutSeconds ?? 300) + 60,
+            hooks: [
+                async (input) => {
+                    if (input.hook_event_name !== 'PreToolUse')
+                        return {};
+                    if (!(await needsHuman(options, input.tool_name, input.tool_input)))
+                        return {};
+                    const decision = await decideToolCall(client, { toolName: input.tool_name, input: input.tool_input, callId: input.tool_use_id }, options);
+                    return {
+                        hookSpecificOutput: {
+                            hookEventName: 'PreToolUse',
+                            permissionDecision: decision.approved ? 'allow' : 'deny',
+                            permissionDecisionReason: decision.reason,
+                        },
+                    };
+                },
+            ],
+        },
+    ];
+}
+async function claudeSdk() {
+    try {
+        const specifier = '@anthropic-ai/claude-agent-sdk';
+        return (await import(specifier));
+    }
+    catch (error) {
+        throw new Error('The Claude Agent SDK integration needs @anthropic-ai/claude-agent-sdk. Install it with: ' +
+            'npm install @anthropic-ai/claude-agent-sdk', { cause: error });
+    }
+}
+const text = (value) => ({ content: [{ type: 'text', text: value }] });
+/**
+ * `m91_request_approval` and `m91_send_alert` as an in-process MCP server.
+ * Register it under `mcpServers.m91`; the tools appear to Claude as
+ * `mcp__m91__m91_request_approval` and `mcp__m91__m91_send_alert`.
+ */
+export async function createM91McpServer(client, defaults = {}) {
+    const { tool, createSdkMcpServer } = await claudeSdk();
+    const z = await loadZod('Claude Agent SDK');
+    return createSdkMcpServer({
+        name: 'm91',
+        tools: [
+            tool(APPROVAL_TOOL_NAME, APPROVAL_DESCRIPTION, approvalShape(z), async (args) => text(await runApproval(client, args, defaults))),
+            tool(ALERT_TOOL_NAME, ALERT_DESCRIPTION, alertShape(z), async (args) => text(await runAlert(client, args, defaults))),
+        ],
+    });
+}
+//# sourceMappingURL=claude-agent-sdk.js.map

package/dist/src/integrations/claude-agent-sdk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-agent-sdk.js","sourceRoot":"","sources":["../../../src/integrations/claude-agent-sdk.ts"],"names":[],"mappings":"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"}

package/dist/src/integrations/google-adk.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Google Agent Development Kit for TypeScript (`@google/adk`): M91 as a
+ * before-tool gate, and M91 as tools.
+ *
+ * **Gate.** `createM91BeforeToolCallback` goes in an `LlmAgent`'s
+ * `beforeToolCallback`. Calls to the tools you name ring a phone first; if the
+ * person rejects (or does not answer), the tool does not run and the agent
+ * gets the reason back as the tool's result.
+ *
+ * ```ts
+ * import { LlmAgent } from '@google/adk';
+ * import { M91Client } from '@msg91comm/m91';
+ * import { createM91BeforeToolCallback, createM91Tools } from '@msg91comm/m91/integrations/google-adk';
+ *
+ * const client = new M91Client(process.env.M91_SEND_LINK!);
+ *
+ * const agent = new LlmAgent({
+ *   name: 'support_agent',
+ *   model: 'gemini-2.5-flash',
+ *   instruction: 'Resolve refund requests.',
+ *   tools: [issueRefund, ...(await createM91Tools(client))],
+ *   beforeToolCallback: createM91BeforeToolCallback(client, { tools: ['issue_refund'] }),
+ * });
+ * ```
+ *
+ * The gate waits for the answer in-process. For approvals that take hours,
+ * use ADK's own Tool Confirmation and resume the session when M91's answer
+ * arrives.
+ */
+import type { BaseTool, SingleBeforeToolCallback } from '@google/adk';
+import type { M91Client } from '../client.js';
+import { type AlertDefaults, type ApprovalDefaults, type GateOptions } from './specs.js';
+/**
+ * A `beforeToolCallback` that asks a person on their phone before the tools
+ * in `options.tools` run. Returning a result object skips the tool, which is
+ * how a rejection reaches the model.
+ */
+export declare function createM91BeforeToolCallback(client: M91Client, options: GateOptions & {
+    tools: NonNullable<GateOptions['tools']>;
+}): SingleBeforeToolCallback;
+/** The blocking approval tool, `m91_request_approval`, as an ADK `FunctionTool`. */
+export declare function createM91ApprovalTool(client: M91Client, defaults?: ApprovalDefaults): Promise<BaseTool>;
+/** The fire-and-forget alert tool, `m91_send_alert`, as an ADK `FunctionTool`. */
+export declare function createM91AlertTool(client: M91Client, defaults?: AlertDefaults): Promise<BaseTool>;
+/** Both tools, for an agent's `tools` array. */
+export declare function createM91Tools(client: M91Client, defaults?: ApprovalDefaults & AlertDefaults): Promise<BaseTool[]>;
+//# sourceMappingURL=google-adk.d.ts.map

package/dist/src/integrations/google-adk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google-adk.d.ts","sourceRoot":"","sources":["../../../src/integrations/google-adk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAgB,wBAAwB,EAAE,MAAM,aAAa,CAAC;AAEpF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAML,KAAK,aAAa,EAElB,KAAK,gBAAgB,EACrB,KAAK,WAAW,EAKjB,MAAM,YAAY,CAAC;AAGpB;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,WAAW,GAAG;IAAE,KAAK,EAAE,WAAW,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC,CAAA;CAAE,GAClE,wBAAwB,CAS1B;AAkBD,oFAAoF;AACpF,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,gBAAqB,GAC9B,OAAO,CAAC,QAAQ,CAAC,CASnB;AAED,kFAAkF;AAClF,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,aAAkB,GAC3B,OAAO,CAAC,QAAQ,CAAC,CASnB;AAED,gDAAgD;AAChD,wBAAsB,cAAc,CAClC,MAAM,EAAE,SAAS,EACjB,QAAQ,GAAE,gBAAgB,GAAG,aAAkB,GAC9C,OAAO,CAAC,QAAQ,EAAE,CAAC,CAErB"}