@t4h.framework/amber 0.1.0 → 0.2.0

package/.ai/skills/framework-amber/SKILL.md

@@ -0,0 +1,225 @@
+---
+name: framework-amber
+description: >-
+  Guides correct use of @t4h.framework/amber in T4H Framework workflows: the
+  `Amber` client, the generic `Service` model and the `Ticket` model, the
+  workflow-run lock, waiting for an agent to tabulate a ticket, the webhook
+  event schema, `AmberWebhook.authorization`, host registration of the
+  activities, and how to test workflows that use them. Use when a workflow
+  must open or drive Amber tickets, when wiring an Amber webhook channel to a
+  host, or when working in packages/amber.
+---
+
+# @t4h.framework/amber
+
+Drive an Amber **webhook channel** from a workflow: create tickets, act on
+them, and suspend until something happens on the Amber side (an agent
+tabulates the ticket) without polling. Package path:
+`alexandria/packages/amber`. Peer dependencies: `@t4h.framework/core`, `@t4h.framework/http`, `@t4h.framework/fs`,
+`@t4h.framework/cache`, `typebox`.
+
+## Import surface
+
+Import from the package root only. Everything else under `src/` (form
+builders, message converters, webhook header constants, schema factories) is
+internal and not exported.
+
+```typescript
+import {
+  Amber,
+  Service,
+  Ticket,
+  AmberWebhook,
+  AMBER_WEBHOOK_EVENT_TYPES,
+  AmberServiceTabulateEventSchema,
+  type AmberConfig,
+  type ServiceRequestConfig,
+} from '@t4h.framework/amber'
+```
+
+`Service` is the generic base (`transfer`, `tabulate`, `update`, `finish`);
+`Ticket` adds the ticket-only methods. Workflow code uses **`Amber` /
+`Ticket`**. The activity classes (`Amber*Activity`) are exported so hosts can
+register them; workflow code never instantiates them.
+
+## Configuration
+
+```typescript
+const amber = new Amber({
+  url: env.AMBER_URL, // Amber API root, e.g. https://amber.example.com
+  tenant: env.AMBER_TENANT,
+  channel: env.AMBER_CHANNEL, // the webhook channel id
+  clientId: env.AMBER_CLIENT_ID,
+  clientSecret: env.AMBER_CLIENT_SECRET,
+})
+```
+
+Every request goes to `{url}/v1/tenants/{tenant}/channels/{channel}` with the
+channel credentials as basic auth. Secrets come from `env`, never literals.
+Every method takes an optional last argument `{ retry }` (`ServiceRequestConfig`)
+forwarded to the HTTP activity.
+
+## Tickets
+
+```typescript
+const ticket = await amber.createTicket({
+  protocol: 'P-123',
+  skill: 'skill-id',
+  tabulationOption: 'option-id',
+  customers: [{ isOwner: true, type: 'customer' }],
+  fields: { customer: [{ name: 'email', value: 'a@b.c' }] },
+})
+
+await ticket.comment({ type: 'public', content: 'Looking into it' })
+await ticket.interact({ content: 'Hello', contentType: 'text/plain' })
+await ticket.updateField({ field: 'field-id', value: 'new value' })
+const fields = await ticket.fields()
+await ticket.lock({ expiresAt: new Date(Date.now() + 3600_000) })
+await ticket.releaseLock()
+await ticket.tabulate({ tabulationOption: 'option-id', notes: [{ type: 'public', content: 'ok' }] })
+await ticket.finish() // update({ status: 'finished' })
+
+const again = await amber.getTicket(ticket.id) // rejects if the service is not a ticket
+```
+
+### The workflow lock
+
+A ticket is **born locked** with `ref` = the workflow unique identifier
+(`GetWorkflowUniqueIdentifierClaim`), so no agent picks it up while the workflow
+still works on it. `lock`, `releaseLock` and the `lockRelease` of a transfer all
+use the same ref, which is why they need no state passed between them.
+
+- `createTicket({ lock: false })` creates it unlocked.
+- `createTicket({ lock: { expiresAt, metadata } })` customises the lock.
+- The ref is never user-supplied; do not try to release a lock owned by
+  another workflow.
+
+### Handing the ticket to a human and waiting
+
+```typescript
+const transfer = await ticket.transfer({
+  skill: 'human-skill-id',
+  status: 'in-queue',
+})
+
+const { tabulation } = await transfer.wait()
+tabulation?.tabulationOption.id
+tabulation?.notes
+```
+
+- `transfer` (like every async activity bound through `History.bind`) returns
+  an `AsyncActivityAwaitable`; the output comes from `await transfer.wait()`.
+  Do other work between the two awaits if you need to.
+- `status: 'in-queue'` releases the workflow lock and `wait()` **suspends** the
+  workflow until an agent tabulates the ticket (`service:tabulate` event).
+  Informative tabulations are ignored; the wait continues.
+- A transfer to a `user` or without `status: 'in-queue'` settles at once and
+  `wait()` resolves with `{ service, serviceTransfer }` and no `tabulation`.
+  Add `lockRelease: true` to release the lock on those too.
+- There is no timeout on the transfer wait. Wrap it in your own deadline logic
+  if the workflow must not hang forever.
+- An HTTP status other than 200 on the transfer request rejects the activity.
+
+## Activities (host registration)
+
+Every model method is an activity recorded in the history and replayable.
+Hosts register them by class:
+
+| Activity | Kind | Claims used |
+|---|---|---|
+| `AmberCreateTicketActivity` | HTTP | `HttpClientRequestClaim`, `FileSystemClaim`, `GetWorkflowUniqueIdentifierClaim` |
+| `AmberLockTicketActivity`, `AmberReleaseTicketLockActivity` | HTTP | same as above |
+| `AmberGetTicketActivity`, `AmberCommentTicketActivity`, `AmberInteractTicketActivity`, `AmberFindTicketFieldsActivity`, `AmberUpdateTicketFieldValueActivity` | HTTP | `HttpClientRequestClaim`, `FileSystemClaim` |
+| `AmberTabulateServiceActivity`, `AmberUpdateServiceActivity` | HTTP | `HttpClientRequestClaim`, `FileSystemClaim` |
+| `AmberTransferServiceActivity` | **Async** | `HttpClientRequestClaim`, `GetWorkflowUniqueIdentifierClaim` |
+
+HTTP activities extend `AbstractAmberHttpRequestActivity`, which extends the
+`http` package's `AbstractHttpRequestActivity` (hence `FileSystemClaim`, where
+the response body is persisted). Extend it only when adding a new Amber
+endpoint to this package.
+
+## Webhook channel and host contract
+
+Amber emits events (`service:tabulate`) to the URL configured on the webhook
+channel. Point it at the **events route** of the workflow on the host that
+runs it:
+
+```
+POST {runtime}/tenants/{tenant}/projects/{project}/workflows/{workflow}/events
+```
+
+Nothing is stored on the Amber side to find the run back (no metadata, no ids
+in the ticket). The host must:
+
+1. Ask each pending async activity for `toCorrelationKey(event)`.
+   `AmberTransferServiceActivity` answers with the Amber **service id** taken
+   from `event.body.data.service.id`, or `undefined` when the event is not
+   theirs (it also ignores `isInformative: true`).
+2. Verify the signature with the `auth` the pending declares:
+   `AmberWebhook.authorization(channelUrl)` returns an
+   `AsyncActivityCallbackAuthJwks` (detached signature over `{timestamp}.{body}`,
+   key resolved by `kid` at `{url}/tenants/{tenant}/.well-known/jwks.json`,
+   300 s tolerance). The host needs the `jwks` authorizer from
+   `@t4h.framework/jwks/callback` and the **raw body**.
+3. Validate the body against the pending `schema`
+   (`AmberServiceTabulateEventSchema`) and advance.
+
+`AmberWebhook.isEvent(body, type)` and `AmberWebhook.serviceId(event, type)`
+are the helpers the activities use and are safe for host-side routing.
+`AMBER_WEBHOOK_EVENT_TYPES` holds the event type strings; Amber may prefix
+them (`amber.service:tabulate`), the matchers accept both.
+
+**One webhook channel serves one workflow.** A project with several Amber
+workflows needs one channel per workflow, because correlation is by service id
+only.
+
+## Testing
+
+Test the **workflow**, not the activities, with `TestWorkflowEnvironment`
+from `@t4h.framework/core/testing` (see the **framework-workflow-testing**
+skill). Provide:
+
+- `HttpClientRequestClaim` and `FileSystemClaim` mocks for the HTTP activities
+  (same shape as in the **framework-http** skill). Create/get responses must be
+  `200` with a JSON body carrying `id` and, for `get`, `type: 'ticket'`.
+- `GetWorkflowUniqueIdentifierClaim` returning a fixed string; it becomes the
+  lock `ref` you can assert on.
+- `mockAsync()` outcomes for the async activity:
+
+```typescript
+import { mockAsync, fulfilled, rejected } from '@t4h.framework/core/testing'
+import { AmberTransferServiceActivity } from '@t4h.framework/amber'
+
+mockAsyncActivity: mockAsync().on(
+  AmberTransferServiceActivity,
+  fulfilled({
+    service: 'svc-1',
+    serviceTransfer: 'transfer-1',
+    tabulation: {
+      id: 'tabulation-1',
+      name: 'Outcome',
+      tabulationOption: { id: 'opt-1', name: 'Resolved' },
+      notes: [],
+    },
+  }),
+)
+```
+
+Use `rejected({ reason: 'timeout', service: 'svc-1', serviceTransfer: 'transfer-1' })`
+to exercise the transfer timeout path.
+
+## Pitfalls
+
+- Do not import from `@t4h.framework/amber/dist/...` or `src/...`; only the root
+  export is stable.
+- Do not create the ticket unlocked and lock it later "to be safe"; the default
+  lock already covers the window between creation and the first transfer.
+- `ticket.transfer` returns an awaitable, not the output. Forgetting `.wait()`
+  gives you an object with no `tabulation` and no type error at the call site.
+- `ticket.transfer` without `status: 'in-queue'` does **not** wait. If the
+  workflow expects a tabulation, it must send `in-queue`.
+- `transfer` without `timeoutInMs` suspends indefinitely if nobody tabulates.
+- `amber.getTicket` on a service that is not a ticket rejects; the model
+  returned by `createTicket` is already the right type.
+- `Amber` and `Ticket` hold credentials in memory only; they are rebuilt from
+  the activity output on replay, never persisted by you.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tech for humans
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # @t4h.framework/amber
 
-Amber module for the [T4H Framework](https://github.com/tech4humans-brasil/alexandria). It provides a client for the Amber service API with support for creating and managing service tickets, using OAuth2 client credentials (LapisLazuli) for authentication.
+Amber module for the [T4H Framework](https://github.com/tech4humans-brasil/alexandria). It drives an Amber **webhook channel** from a workflow: create tickets, act on them, and wait for what happens on the Amber side (an agent tabulating a ticket) without polling.
 
 ## Installation
 
@@ -8,107 +8,117 @@ Amber module for the [T4H Framework](https://github.com/tech4humans-brasil/alexa
 yarn add @t4h.framework/amber
 ```
 
-**Peer dependencies:** `@t4h.framework/core`, `@t4h.framework/http`, `@t4h.framework/metadata`, `@t4h.framework/runtime-claims`, and `typebox`.
+**Peer dependencies:** `@t4h.framework/core`, `@t4h.framework/http`, `@t4h.framework/fs`, `@t4h.framework/cache` and `typebox`.
 
 ## Configuration
 
-Create a `Amber` instance with the Amber base URL and LapisLazuli OAuth2 credentials:
-
 ```ts
 import { Amber } from '@t4h.framework/amber'
 
 const amber = new Amber({
-  url: 'https://your-amber-api.example.com',
-  auth: {
-    tokenUrl: 'https://auth.example.com/oauth/token',
-    clientId: 'your-client-id',
-    clientSecret: 'your-client-secret',
-    tenantId: 'your-tenant-id',
-  },
+  url: 'https://amber.example.com', // Amber API root
+  tenant: 'your-tenant-id',
+  channel: 'your-webhook-channel-id',
+  clientId: 'channel-client-id',
+  clientSecret: 'channel-client-secret',
 })
 ```
 
-## Usage
+Every call goes to `{url}/v1/tenants/{tenant}/channels/{channel}` with the channel credentials as basic auth.
+
+### Point the channel webhook at the workflow
+
+Amber emits its events (`service:tabulate`, …) to the URL configured on the webhook channel. Set it to the **events route** of the workflow that uses this package, on the host that runs it:
+
+```
+POST {runtime}/tenants/{tenant}/projects/{project}/workflows/{workflow}/events
+```
+
+The host asks the waiting activities which event is theirs (`toCorrelationKey`, keyed by the Amber service id), verifies the signature Amber puts on every event (detached signature over `timestamp.body`, key resolved by `kid` at `{url}/tenants/{tenant}/.well-known/jwks.json`) and advances the right wait. Nothing is stored on the Amber side to find the run back: no metadata, no ids in the ticket.
+
+One webhook channel serves one workflow. A project with several Amber workflows needs one channel per workflow.
 
-### Creating a ticket
+## Tickets
 
 ```ts
 const ticket = await amber.createTicket({
-  input: {
-    type: 'ticket',
-    channel: 'your-channel',
-    protocol: 'protocol-id',
-    skill: 'skill-id',
-    tabulationOption: 'option-id',
-    customers: [
-      {
-        isOwner: true,
-        type: 'customer-type',
-      },
-    ],
-  },
+  protocol: 'P-123',
+  skill: 'skill-id',
+  tabulationOption: 'option-id',
+  customers: [{ isOwner: true, type: 'customer' }],
+  fields: { customer: [{ name: 'email', value: 'a@b.c' }] },
+})
+```
+
+A ticket is **born locked** by the workflow (`lock: { ref: <workflow id> }`), so no agent picks it up while the workflow still works on it. Pass `lock: false` to create it unlocked, or `lock: { expiresAt, metadata }` to customize the lock.
+
+The lock `ref` is the **workflow id** the host reports through `GetWorkflowUniqueIdentifierClaim` (`amber-ticket` for a workflow declared with `id: 'amber-ticket'`), not the id of the run. `lock()`, `releaseLock()` and the lock release of `transfer()` use the same `ref`, so every run of a workflow can release a lock another run of it took.
+
+A locked ticket still takes comments, interactions and field updates from the workflow, but Amber answers `423` to a `lock()` while a lock exists (release first, lock again) and to a `tabulate()` while the ticket is locked, even by the workflow itself. Release the lock before tabulating or finishing the ticket. Transfers release it for you with `status: 'in-queue'` or `lockRelease: true`.
+
+```ts
+await ticket.comment({ type: 'public', content: 'Looking into it' })
+await ticket.interact({ content: 'Hello', contentType: 'text/plain' })
+await ticket.updateField({ field: 'field-id', value: 'new value' })
+const fields = await ticket.fields()
+
+await ticket.lock({ expiresAt: new Date(Date.now() + 3600_000) })
+await ticket.releaseLock()
+```
+
+### Handing the ticket to a human and waiting
+
+```ts
+const transfer = await ticket.transfer({
+  skill: 'human-skill-id',
+  status: 'in-queue',
 })
+
+const { tabulation } = await transfer.wait()
 ```
 
-`createTicket` returns a `Ticket` instance you can use to perform further actions.
+`transfer` returns an awaitable. Transferring to `in-queue` **releases the workflow lock**, and `wait()` suspends the workflow until an agent tabulates the ticket, resolving with the tabulation the agent chose (`tabulation.tabulationOption`, `tabulation.notes`). Informative tabulations are ignored. A transfer to a user or without `status: 'in-queue'` settles at once and `wait()` resolves without `tabulation`; add `lockRelease: true` to release the lock on those too.
 
-### Getting a ticket
+The wait has no deadline by default. Pass `timeoutInMs` in the second argument, next to `retry`, to bound it; `wait()` then rejects with `{ reason: 'timeout', service, serviceTransfer }` when the agent has not tabulated in time:
 
 ```ts
-const ticket = await amber.getTicket({ id: 'ticket-id' })
+const transfer = await ticket.transfer(
+  { skill: 'human-skill-id', status: 'in-queue' },
+  { timeoutInMs: 24 * 60 * 60 * 1000, retry: true },
+)
 ```
 
-### Working with a ticket
+When the transfer released the lock (`status: 'in-queue'` or `lockRelease: true`), `wait()` on a **ticket** **locks it back** for the workflow before resolving, with no expiration, so no agent picks it up again while the workflow finishes it. Pass `lock: false` in the second argument to skip that, or `lock: { expiresAt, metadata }` to customize the lock. The lock is a separate `AmberLockTicketActivity` recorded after the transfer, and a refusal by Amber rejects `wait()` with its `AmberRequestError`.
 
-Once you have a `Ticket` (from `createTicket` or `getTicket`), you can:
+```ts
+const transfer = await ticket.transfer(
+  { skill: 'human-skill-id', status: 'in-queue' },
+  { lock: { expiresAt: new Date(Date.now() + 3600_000) } },
+)
 
-- **Comment** — add a comment to the ticket
-- **Interact** — record a service interaction
-- **Tabulate** — update tabulation data
-- **Transfer** — transfer the ticket
-- **Update** — update ticket fields
-- **Finish** — set the ticket status to finished
+const { tabulation } = await transfer.wait() // ticket locked again here
+```
 
 ```ts
-await ticket.comment({ input: { body: 'Comment text' } })
-await ticket.interact({
-  input: {
-    /* interaction data */
-  },
-})
 await ticket.tabulate({
-  input: {
-    /* tabulation data */
-  },
-})
-await ticket.transfer({
-  input: {
-    /* transfer data */
-  },
+  tabulationOption: 'option-id',
+  notes: [{ type: 'public', content: 'ok' }],
 })
-await ticket.update({ input: { status: 'in-attendance' } })
 await ticket.finish()
 ```
 
-## Activities
-
-The package also exports individual activities for use within T4H workflows:
+## Errors
 
-- `AmberCreateTicketActivity`
-- `AmberGetTicketActivity`
-- `AmberCommentTicketActivity`
-- `AmberInteractTicketActivity`
-- `AmberTabulateTicketActivity`
-- `AmberTransferTicketActivity`
-- `AmberUpdateTicketActivity`
+Every call that Amber answers with a status other than `200` rejects with an `AmberRequestError`. Its `message` carries the status and the response body, which is where Amber says what it refused, so the reason shows up in any log that prints only the message:
 
-These are used internally by `Amber` and `Ticket`; use the `Amber`/`Ticket` API unless you need to plug activities directly into your workflow.
+```
+Failed to create ticket: Amber responded 400 {"errors":{"$.tabulationOption":["Not found tabulation option"]}}
+```
 
-## Requirements
+The same data is available as `error.status`, `error.body` and `error.cause` (`{ httpStatusCode, body }`). Bodies longer than 2000 characters are truncated. The activity that waits on Amber events, `transfer()`, rejects its awaitable with that message as the payload instead.
 
-- **Node.js** ≥ 22
-- T4H Framework peer packages
+## Activities
 
-## License
+Every method above is an activity, recorded in the workflow history and replayable. Hosts register them by class: `AmberCreateTicketActivity`, `AmberGetTicketActivity`, `AmberCommentTicketActivity`, `AmberInteractTicketActivity`, `AmberTabulateServiceActivity`, `AmberTransferServiceActivity`, `AmberUpdateServiceActivity`, `AmberLockTicketActivity`, `AmberReleaseTicketLockActivity`, `AmberFindTicketFieldsActivity`, `AmberUpdateTicketFieldValueActivity`.
 
-MIT © [Tech4Humans](https://tech4h.com.br)
+`AmberTransferServiceActivity` is the one that waits on Amber events; the schema it validates the events against (`AmberServiceTabulateEventSchema`) and the `auth` it declares (`AmberWebhook.authorization(channelUrl)`) are exported by the package.

package/dist/activities/AbstractAmberHttpRequestActivity.d.ts

@@ -1,9 +1,6 @@
-import { AbstractHttpRequestActivity, type HttpRequestActivityInput, type HttpRequestActivityOutput } from '@t4h.framework/http';
+import { AbstractHttpRequestActivity, type HttpRequestActivityInput, type HttpRequestActivityOutput, type HttpRequestBasicAuth } from '@t4h.framework/http';
 export type AmberHttpRequestActivityInput = HttpRequestActivityInput & {
-    auth: {
-        username: string;
-        password: string;
-    };
+    auth: HttpRequestBasicAuth;
 };
 export declare abstract class AbstractAmberHttpRequestActivity<TArgs extends readonly any[], TInput extends AmberHttpRequestActivityInput, TOutput = any> extends AbstractHttpRequestActivity<TArgs, TInput, HttpRequestActivityOutput, TOutput> {
     protected toHttpInput(input: AmberHttpRequestActivityInput): HttpRequestActivityInput;

package/dist/activities/AbstractAmberHttpRequestActivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractAmberHttpRequestActivity.d.ts","sourceRoot":"","sources":["../../src/activities/AbstractAmberHttpRequestActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC/B,MAAM,qBAAqB,CAAA;AAE5B,MAAM,MAAM,6BAA6B,GAAG,wBAAwB,GAAG;IACrE,IAAI,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAA;CAC7C,CAAA;AAED,8BAAsB,gCAAgC,CACpD,KAAK,SAAS,SAAS,GAAG,EAAE,EAC5B,MAAM,SAAS,6BAA6B,EAC5C,OAAO,GAAG,GAAG,CACb,SAAQ,2BAA2B,CACnC,KAAK,EACL,MAAM,EACN,yBAAyB,EACzB,OAAO,CACR;IACC,SAAS,CAAC,WAAW,CACnB,KAAK,EAAE,6BAA6B,GACnC,wBAAwB;IAgB3B,SAAS,CAAC,YAAY,CACpB,MAAM,EAAE,yBAAyB,GAChC,yBAAyB;CAG7B"}
+{"version":3,"file":"AbstractAmberHttpRequestActivity.d.ts","sourceRoot":"","sources":["../../src/activities/AbstractAmberHttpRequestActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,oBAAoB,EAC1B,MAAM,qBAAqB,CAAA;AAE5B,MAAM,MAAM,6BAA6B,GAAG,wBAAwB,GAAG;IACrE,IAAI,EAAE,oBAAoB,CAAA;CAC3B,CAAA;AAED,8BAAsB,gCAAgC,CACpD,KAAK,SAAS,SAAS,GAAG,EAAE,EAC5B,MAAM,SAAS,6BAA6B,EAC5C,OAAO,GAAG,GAAG,CACb,SAAQ,2BAA2B,CACnC,KAAK,EACL,MAAM,EACN,yBAAyB,EACzB,OAAO,CACR;IACC,SAAS,CAAC,WAAW,CACnB,KAAK,EAAE,6BAA6B,GACnC,wBAAwB;IAgB3B,SAAS,CAAC,YAAY,CACpB,MAAM,EAAE,yBAAyB,GAChC,yBAAyB;CAG7B"}

package/dist/activities/AbstractAmberHttpRequestActivity.js.map

@@ -1 +1 @@
-{"version":3,"file":"AbstractAmberHttpRequestActivity.js","sourceRoot":"","sources":["../../src/activities/AbstractAmberHttpRequestActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,GAG5B,MAAM,qBAAqB,CAAA;AAM5B,MAAM,OAAgB,gCAIpB,SAAQ,2BAKT;IACW,WAAW,CACnB,KAAoC;QAEpC,MAAM,SAAS,GAA6B;YAC1C,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,EAAE;YAC5B,IAAI,EAAE,KAAK,CAAC,IAAI;SACjB,CAAA;QAED,IAAI,KAAK,CAAC,MAAM;YAAE,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAA;QAEjD,IAAI,KAAK,CAAC,IAAI;YAAE,SAAS,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAA;QAE3C,IAAI,KAAK,CAAC,KAAK;YAAE,SAAS,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAA;QAE9C,OAAO,SAAS,CAAA;IAClB,CAAC;IAES,YAAY,CACpB,MAAiC;QAEjC,OAAO,MAAM,CAAA;IACf,CAAC;CACF"}
+{"version":3,"file":"AbstractAmberHttpRequestActivity.js","sourceRoot":"","sources":["../../src/activities/AbstractAmberHttpRequestActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,2BAA2B,GAI5B,MAAM,qBAAqB,CAAA;AAM5B,MAAM,OAAgB,gCAIpB,SAAQ,2BAKT;IACW,WAAW,CACnB,KAAoC;QAEpC,MAAM,SAAS,GAA6B;YAC1C,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,EAAE;YAC5B,IAAI,EAAE,KAAK,CAAC,IAAI;SACjB,CAAA;QAED,IAAI,KAAK,CAAC,MAAM;YAAE,SAAS,CAAC,MAAM,GAAG,KAAK,CAAC,MAAM,CAAA;QAEjD,IAAI,KAAK,CAAC,IAAI;YAAE,SAAS,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAA;QAE3C,IAAI,KAAK,CAAC,KAAK;YAAE,SAAS,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAA;QAE9C,OAAO,SAAS,CAAA;IAClB,CAAC;IAES,YAAY,CACpB,MAAiC;QAEjC,OAAO,MAAM,CAAA;IACf,CAAC;CACF"}

package/dist/activities/AmberTabulateServiceActivity.d.ts

@@ -0,0 +1,10 @@
+import { AbstractAmberHttpRequestActivity, type AmberHttpRequestActivityInput } from './AbstractAmberHttpRequestActivity.js';
+import type { ServiceTabulationInput } from '../typings/ServiceTabulate.js';
+export type AmberTabulateServiceActivityInput = ServiceTabulationInput & {
+    id: string;
+};
+export declare class AmberTabulateServiceActivity extends AbstractAmberHttpRequestActivity<readonly [AmberTabulateServiceActivityInput, AmberHttpRequestActivityInput], AmberHttpRequestActivityInput> {
+    toInput(input: AmberTabulateServiceActivityInput, settings: AmberHttpRequestActivityInput): AmberHttpRequestActivityInput;
+    toOutput(output: any, input: AmberTabulateServiceActivityInput): Promise<void>;
+}
+//# sourceMappingURL=AmberTabulateServiceActivity.d.ts.map

package/dist/activities/AmberTabulateServiceActivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmberTabulateServiceActivity.d.ts","sourceRoot":"","sources":["../../src/activities/AmberTabulateServiceActivity.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,gCAAgC,EAChC,KAAK,6BAA6B,EACnC,MAAM,uCAAuC,CAAA;AAE9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+BAA+B,CAAA;AAE3E,MAAM,MAAM,iCAAiC,GAAG,sBAAsB,GAAG;IACvE,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAED,qBAAa,4BAA6B,SAAQ,gCAAgC,CAChF,SAAS,CAAC,iCAAiC,EAAE,6BAA6B,CAAC,EAC3E,6BAA6B,CAC9B;IACQ,OAAO,CACZ,KAAK,EAAE,iCAAiC,EACxC,QAAQ,EAAE,6BAA6B,GACtC,6BAA6B;IAWnB,QAAQ,CACnB,MAAM,EAAE,GAAG,EACX,KAAK,EAAE,iCAAiC,GACvC,OAAO,CAAC,IAAI,CAAC;CASjB"}

package/dist/activities/AmberTabulateServiceActivity.js

@@ -0,0 +1,20 @@
+import { Response } from '@t4h.framework/http';
+import { AbstractAmberHttpRequestActivity, } from './AbstractAmberHttpRequestActivity.js';
+import { AmberRequestError } from '../errors/AmberRequestError.js';
+export class AmberTabulateServiceActivity extends AbstractAmberHttpRequestActivity {
+    toInput(input, settings) {
+        const { id, ...tabulation } = input;
+        return {
+            ...settings,
+            url: `${settings.url}/services/${id}/tabulations`,
+            method: 'POST',
+            body: { json: tabulation },
+        };
+    }
+    async toOutput(output, input) {
+        const response = new Response(output);
+        if (response.status !== 200)
+            throw await AmberRequestError.from(`Failed to tabulate service ${input.id}`, response);
+    }
+}
+//# sourceMappingURL=AmberTabulateServiceActivity.js.map

package/dist/activities/AmberTabulateServiceActivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmberTabulateServiceActivity.js","sourceRoot":"","sources":["../../src/activities/AmberTabulateServiceActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAA;AAE9C,OAAO,EACL,gCAAgC,GAEjC,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAA;AAOlE,MAAM,OAAO,4BAA6B,SAAQ,gCAGjD;IACQ,OAAO,CACZ,KAAwC,EACxC,QAAuC;QAEvC,MAAM,EAAE,EAAE,EAAE,GAAG,UAAU,EAAE,GAAG,KAAK,CAAA;QAEnC,OAAO;YACL,GAAG,QAAQ;YACX,GAAG,EAAE,GAAG,QAAQ,CAAC,GAAG,aAAa,EAAE,cAAc;YACjD,MAAM,EAAE,MAAM;YACd,IAAI,EAAE,EAAE,IAAI,EAAE,UAAU,EAAE;SAC3B,CAAA;IACH,CAAC;IAEM,KAAK,CAAC,QAAQ,CACnB,MAAW,EACX,KAAwC;QAExC,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAA;QAErC,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG;YACzB,MAAM,MAAM,iBAAiB,CAAC,IAAI,CAChC,8BAA8B,KAAK,CAAC,EAAE,EAAE,EACxC,QAAQ,CACT,CAAA;IACL,CAAC;CACF"}

package/dist/activities/AmberTransferServiceActivity.d.ts

@@ -0,0 +1,86 @@
+import { AsyncActivity, type AsyncActivityCallback, type AsyncActivityResultPending } from '@t4h.framework/core';
+import type { Type } from 'typebox';
+import type { AmberHttpRequestActivityInput } from './AbstractAmberHttpRequestActivity.js';
+import { AmberServiceTabulateEventSchema } from '../inputs/AmberServiceTabulateEvent.js';
+import type { ServiceTransferInput } from '../typings/ServiceTransfer.js';
+export type AmberTransferServiceActivityInput = ServiceTransferInput & {
+    id: string;
+    /**
+     * How long an `in-queue` transfer waits for the agent's tabulation before
+     * rejecting with `{ reason: 'timeout' }`. Waits indefinitely when omitted.
+     */
+    timeoutInMs?: number;
+};
+export type AmberTransferServiceActivityBootstrap = {
+    service: string;
+    serviceTransfer: string;
+};
+export type AmberTransferServiceActivityOutput = AmberTransferServiceActivityBootstrap & {
+    tabulation?: {
+        id: string;
+        name: string;
+        tabulationOption: {
+            id: string;
+            name: string;
+        };
+        notes: {
+            id: string;
+            type: 'public' | 'private';
+            content: string;
+            createdAt: string;
+        }[];
+    };
+};
+type AmberTransferServiceActivityBootstrapInput = AmberTransferServiceActivityInput & {
+    settings: AmberHttpRequestActivityInput;
+};
+export declare class AmberTransferServiceActivity extends AsyncActivity<readonly [AmberTransferServiceActivityInput, AmberHttpRequestActivityInput], AmberTransferServiceActivityBootstrapInput, AmberTransferServiceActivityOutput, AmberTransferServiceActivityOutput, AmberTransferServiceActivityBootstrap, typeof AmberServiceTabulateEventSchema> {
+    private readonly claims;
+    toInput(input: AmberTransferServiceActivityInput, settings: AmberHttpRequestActivityInput): AmberTransferServiceActivityBootstrapInput;
+    bootstrap(input: AmberTransferServiceActivityBootstrapInput): Promise<AsyncActivityResultPending<AmberTransferServiceActivityBootstrap, Type.TObject<{
+        specversion: Type.TString;
+        id: Type.TString;
+        type: Type.TString;
+        source: Type.TString;
+        subject: Type.TString;
+        time: Type.TString;
+        data: Type.TObject<{
+            id: Type.TString;
+            isInformative: Type.TBoolean;
+            tabulationOption: Type.TObject<{
+                id: Type.TString;
+                name: Type.TString;
+                tabulation: Type.TObject<{
+                    id: Type.TString;
+                    name: Type.TString;
+                }>;
+            }>;
+            serviceTransfer: Type.TObject<{
+                id: Type.TString;
+                skill: Type.TObject<{
+                    id: Type.TString;
+                    name: Type.TString;
+                }>;
+            }>;
+            notes: Type.TArray<Type.TObject<{
+                id: Type.TString;
+                type: Type.TUnion<[Type.TLiteral<"public">, Type.TLiteral<"private">]>;
+                content: Type.TString;
+                createdAt: Type.TString;
+            }>>;
+            service: Type.TObject<{
+                id: Type.TString;
+            }>;
+            tenant: Type.TObject<{
+                id: Type.TString;
+                name: Type.TOptional<Type.TString>;
+            }>;
+        }>;
+    }>> | import("@t4h.framework/core").AsyncActivityResultRejected<void | import("@t4h.framework/core").Serializable> | import("@t4h.framework/core").AsyncActivityResultFulfilled<AmberTransferServiceActivityOutput | undefined>>;
+    toCorrelationKey(event: AsyncActivityCallback.Event): string | undefined;
+    advance(event: Type.Static<typeof AmberServiceTabulateEventSchema>): import("@t4h.framework/core").AsyncActivityResultFulfilled<AmberTransferServiceActivityOutput | undefined>;
+    onTimeout(bootstrap: AsyncActivityResultPending): import("@t4h.framework/core").AsyncActivityResultRejected<void | import("@t4h.framework/core").Serializable>;
+    toOutput(output: AmberTransferServiceActivityOutput): AmberTransferServiceActivityOutput;
+}
+export {};
+//# sourceMappingURL=AmberTransferServiceActivity.d.ts.map

package/dist/activities/AmberTransferServiceActivity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AmberTransferServiceActivity.d.ts","sourceRoot":"","sources":["../../src/activities/AmberTransferServiceActivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EAIb,KAAK,qBAAqB,EAC1B,KAAK,0BAA0B,EAChC,MAAM,qBAAqB,CAAA;AAE5B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAA;AAEnC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,uCAAuC,CAAA;AAG1F,OAAO,EAAE,+BAA+B,EAAE,MAAM,wCAAwC,CAAA;AAExF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AAEzE,MAAM,MAAM,iCAAiC,GAAG,oBAAoB,GAAG;IACrE,EAAE,EAAE,MAAM,CAAA;IACV;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,qCAAqC,GAAG;IAClD,OAAO,EAAE,MAAM,CAAA;IACf,eAAe,EAAE,MAAM,CAAA;CACxB,CAAA;AAED,MAAM,MAAM,kCAAkC,GAC5C,qCAAqC,GAAG;IACtC,UAAU,CAAC,EAAE;QACX,EAAE,EAAE,MAAM,CAAA;QACV,IAAI,EAAE,MAAM,CAAA;QACZ,gBAAgB,EAAE;YAAE,EAAE,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAE,CAAA;QAC9C,KAAK,EAAE;YACL,EAAE,EAAE,MAAM,CAAA;YACV,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAA;YAC1B,OAAO,EAAE,MAAM,CAAA;YACf,SAAS,EAAE,MAAM,CAAA;SAClB,EAAE,CAAA;KACJ,CAAA;CACF,CAAA;AAEH,KAAK,0CAA0C,GAC7C,iCAAiC,GAAG;IAClC,QAAQ,EAAE,6BAA6B,CAAA;CACxC,CAAA;AAEH,qBAAa,4BAA6B,SAAQ,aAAa,CAC7D,SAAS,CAAC,iCAAiC,EAAE,6BAA6B,CAAC,EAC3E,0CAA0C,EAC1C,kCAAkC,EAClC,kCAAkC,EAClC,qCAAqC,EACrC,OAAO,+BAA+B,CACvC;IACC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAGrB;IAEK,OAAO,CACZ,KAAK,EAAE,iCAAiC,EACxC,QAAQ,EAAE,6BAA6B,GACtC,0CAA0C;IAIhC,SAAS,CAAC,KAAK,EAAE,0CAA0C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyDxD,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,CAAC,KAAK;IAe5D,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,+BAA+B,CAAC;IAuBzD,SAAS,CAAC,SAAS,EAAE,0BAA0B;IAYxD,QAAQ,CACb,MAAM,EAAE,kCAAkC,GACzC,kCAAkC;CAGtC"}