@amigo-ai/platform-sdk 0.26.0 → 0.27.0

package/dist/index.mjs

@@ -960,6 +960,35 @@ var WorkspacesResource = class extends WorkspaceScopedResource {
       })
     );
   }
+  /**
+   * Workspace-allowlisted phone numbers that can place test calls into voice
+   * agents. The list is read-mostly; writes overwrite the entire allowlist.
+   *
+   * Always operates on the bound workspace. Use `client.withOptions(...)` or
+   * construct a second `AmigoClient` if you need to act on a different
+   * workspace.
+   */
+  testCallerNumbers = {
+    /** Get the workspace's test caller allowlist */
+    get: async () => extractData(
+      await this.client.GET("/v1/workspaces/{workspace_id}/test-caller-numbers", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    /**
+     * Replace the workspace's test caller allowlist.
+     *
+     * **Replace-all semantics:** the request body fully replaces the existing
+     * allowlist; numbers omitted from `body` are removed. Read first, mutate,
+     * then write to add/remove individual entries safely.
+     */
+    update: async (body) => extractData(
+      await this.client.PUT("/v1/workspaces/{workspace_id}/test-caller-numbers", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
+  };
 };
 
 // src/resources/api-keys.ts
@@ -1933,6 +1962,34 @@ var CallsResource = class extends WorkspaceScopedResource {
       })
     );
   }
+  /** List trace analyses across calls (workspace-scoped feed) */
+  async listTraces(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls/traces", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** Get latest Universal Metric Store values scoped to a single call */
+  async getMetrics(callId2, params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/calls/{call_id}/metrics", {
+        params: {
+          path: { workspace_id: this.workspaceId, call_id: callId2 },
+          query: params
+        }
+      })
+    );
+  }
+  /** Place an outbound call from the workspace's voice pipeline */
+  async createOutbound(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/calls/outbound", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
 };
 
 // src/resources/conversations.ts
@@ -2614,6 +2671,34 @@ var AnalyticsResource = class extends WorkspaceScopedResource {
       })
     );
   }
+  /**
+   * Surfaces analytics — completion rates, channel effectiveness, field
+   * abandonment, and per-entity breakdowns. Used by the developer console's
+   * surfaces analytics tab.
+   */
+  surfaces = {
+    getCompletionRates: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/surfaces/completion-rates", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    getChannelEffectiveness: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/surfaces/channel-effectiveness", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    getFieldAbandonment: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/surfaces/field-abandonment", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /** Per-entity surfaces analytics (which surfaces a specific entity has seen) */
+    getForEntity: async (entityId2) => extractData(
+      await this.client.GET("/v1/{workspace_id}/analytics/surfaces/entity/{entity_id}", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    )
+  };
 };
 
 // src/resources/simulations.ts
@@ -2675,6 +2760,108 @@ var SimulationsResource = class extends WorkspaceScopedResource {
       })
     );
   }
+  /**
+   * Multi-session simulation runs — orchestrate a batch of scenarios against
+   * a service to compute coverage and surface regressions. Use this when you
+   * want to compare branch behavior or measure drift between versions.
+   *
+   * @beta New in this release; surface may evolve.
+   */
+  runs = {
+    /** List simulation runs in the workspace */
+    list: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/simulations/runs", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /** Create a new simulation run */
+    create: async (body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/runs", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    ),
+    /** Get a simulation run with its scenarios + status */
+    get: async (runId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/simulations/runs/{run_id}", {
+        params: { path: { workspace_id: this.workspaceId, run_id: runId } }
+      })
+    ),
+    /** Mark a run as complete (used by the harness once all sessions finish) */
+    complete: async (runId) => extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/runs/{run_id}/complete", {
+        params: { path: { workspace_id: this.workspaceId, run_id: runId } }
+      })
+    ),
+    /** Spin up a session under a run (single scenario inside the run's batch) */
+    createSession: async (runId, body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/runs/{run_id}/sessions", {
+        params: { path: { workspace_id: this.workspaceId, run_id: runId } },
+        body
+      })
+    )
+  };
+  /**
+   * Bridge — convert recorded production calls into simulation scenarios so
+   * they can be replayed against a candidate version. ``plan`` returns a
+   * preview of which calls would be selected; ``run`` executes the plan.
+   */
+  bridge = {
+    /** Plan a bridge run — returns the candidate scenarios without executing */
+    plan: async (body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/bridge/plan", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    ),
+    /** Execute a bridge run and return the resulting run handle */
+    run: async (body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/simulations/bridge", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    )
+  };
+  /**
+   * Per-service simulation views — graph of explored conversation paths,
+   * recorded sessions, and per-turn telemetry. Used by the developer console's
+   * coverage tab to visualize what scenarios have been exercised.
+   */
+  services = {
+    /** Get the conversation graph (nodes/edges) for a service */
+    getGraph: async (serviceId2) => extractData(
+      await this.client.GET("/v1/{workspace_id}/simulations/services/{service_id}/graph", {
+        params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+      })
+    ),
+    /** Reset / delete the service's accumulated graph */
+    deleteGraph: async (serviceId2) => extractData(
+      await this.client.DELETE("/v1/{workspace_id}/simulations/services/{service_id}/graph", {
+        params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+      })
+    ),
+    /** Get the set of explored conversation paths through the graph */
+    getGraphPaths: async (serviceId2) => extractData(
+      await this.client.GET(
+        "/v1/{workspace_id}/simulations/services/{service_id}/graph/paths",
+        {
+          params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+        }
+      )
+    ),
+    /** List recorded sessions for the service */
+    listSessions: async (serviceId2) => extractData(
+      await this.client.GET("/v1/{workspace_id}/simulations/services/{service_id}/sessions", {
+        params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+      })
+    ),
+    /** List per-turn observations for the service */
+    listTurns: async (serviceId2) => extractData(
+      await this.client.GET("/v1/{workspace_id}/simulations/services/{service_id}/turns", {
+        params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+      })
+    )
+  };
 };
 
 // src/resources/metrics.ts
@@ -2823,6 +3010,27 @@ var SettingsResource = class extends WorkspaceScopedResource {
         params: { path: { workspace_id: this.workspaceId } },
         body
       })
+    ),
+    /**
+     * Preview which calls would be flagged by the current gap-scanner config.
+     *
+     * The spec types the body as `GapScannerPreviewRequest | null`, but the
+     * `null` branch only matters when the caller wants to *explicitly* clear
+     * the body. Modeling as `body?: GapScannerPreviewRequest` keeps the SDK
+     * surface consistent with every other POST wrapper; consumers who need
+     * to send the literal `null` can do so via `client.POST(...)` directly.
+     */
+    preview: async (body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/settings/gap-scanner/preview", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    ),
+    /** Trigger an on-demand scan with the current gap-scanner config */
+    scan: async () => extractData(
+      await this.client.POST("/v1/{workspace_id}/settings/gap-scanner/scan", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
     )
   };
   scribe = {
@@ -4289,6 +4497,810 @@ function parseObserverFrame(data) {
   return obj;
 }
 
+// src/resources/fhir.ts
+var FhirResource = class extends WorkspaceScopedResource {
+  /** Get current FHIR sync status (server identity, last sync, counts) */
+  async getStatus() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/status", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** List recent FHIR sync failures (for triage) */
+  async getSyncFailures(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/sync-failures", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** Trigger a FHIR import (full or partial, depending on request) */
+  async import(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/fhir/import", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  /** Search patients by demographics or identifiers */
+  async searchPatients(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/patients", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** Get a patient summary (canonical demographics + active conditions/meds) */
+  async getPatientSummary(patientId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/patients/{patient_id}/summary", {
+        params: { path: { workspace_id: this.workspaceId, patient_id: patientId } }
+      })
+    );
+  }
+  /** Get a patient's longitudinal clinical timeline */
+  async getPatientTimeline(patientId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/patients/{patient_id}/timeline", {
+        params: { path: { workspace_id: this.workspaceId, patient_id: patientId } }
+      })
+    );
+  }
+  resources = {
+    /** Search FHIR resources of a given type (passes search params through to FHIR) */
+    search: async (resourceType, params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/resources/{resource_type}", {
+        params: {
+          path: { workspace_id: this.workspaceId, resource_type: resourceType },
+          query: params
+        }
+      })
+    ),
+    /** Create a FHIR resource of the given type */
+    create: async (resourceType, body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/fhir/resources/{resource_type}", {
+        params: { path: { workspace_id: this.workspaceId, resource_type: resourceType } },
+        body
+      })
+    ),
+    /** Get a single FHIR resource by type + id */
+    get: async (resourceType, resourceId) => extractData(
+      await this.client.GET(
+        "/v1/{workspace_id}/fhir/resources/{resource_type}/{resource_id}",
+        {
+          params: {
+            path: {
+              workspace_id: this.workspaceId,
+              resource_type: resourceType,
+              resource_id: resourceId
+            }
+          }
+        }
+      )
+    ),
+    /** Update a FHIR resource by type + id */
+    update: async (resourceType, resourceId, body) => extractData(
+      await this.client.PUT(
+        "/v1/{workspace_id}/fhir/resources/{resource_type}/{resource_id}",
+        {
+          params: {
+            path: {
+              workspace_id: this.workspaceId,
+              resource_type: resourceType,
+              resource_id: resourceId
+            }
+          },
+          body
+        }
+      )
+    ),
+    /** Get the version history for a FHIR resource */
+    getHistory: async (resourceType, resourceId) => extractData(
+      await this.client.GET(
+        "/v1/{workspace_id}/fhir/resources/{resource_type}/{resource_id}/history",
+        {
+          params: {
+            path: {
+              workspace_id: this.workspaceId,
+              resource_type: resourceType,
+              resource_id: resourceId
+            }
+          }
+        }
+      )
+    )
+  };
+  views = {
+    /** List patients (typed view with computed display fields) */
+    patients: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/views/patients", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /** List appointments */
+    appointments: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/views/appointments", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /** List practitioners */
+    practitioners: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/views/practitioners", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /** List organizations */
+    organizations: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/views/organizations", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /** List locations */
+    locations: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/views/locations", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /**
+     * List schedule slots — supports richer filtering than the other views
+     * (status, date window, provider, specialty, service_type, facility_id).
+     */
+    slots: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/fhir/views/slots", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    )
+  };
+};
+
+// src/resources/insights.ts
+var InsightsResource = class extends WorkspaceScopedResource {
+  /** Get the periodic insights digest for the workspace */
+  async getDigest() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/insights/digest", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Fetch the queryable schema (tables, columns, joins) the assistant uses */
+  async getSchema() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/insights/schema", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Get curated query suggestions for the workspace */
+  async getSuggestions() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/insights/suggestions", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Run an ad-hoc SQL query against the insights warehouse */
+  async runSql(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/insights/sql", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  sessions = {
+    /** Start a new insights chat session */
+    create: async () => extractData(
+      await this.client.POST("/v1/{workspace_id}/insights/sessions", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    /** Get a session and its full history */
+    get: async (sessionId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/insights/sessions/{session_id}", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } }
+      })
+    ),
+    /** Send a chat message and get the assistant's response (with any generated SQL/results) */
+    chat: async (sessionId, body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/insights/sessions/{session_id}/chat", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } },
+        body
+      })
+    )
+  };
+};
+
+// src/resources/monitor-concepts.ts
+var MonitorConceptsResource = class extends WorkspaceScopedResource {
+  /** Create a new monitor concept */
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/monitor-concepts", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  /** List monitor concepts in the workspace */
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/monitor-concepts", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  listAutoPaging(params) {
+    return this.iteratePaginatedList((pageParams) => this.list(pageParams), params);
+  }
+  /** Get a single monitor concept */
+  async get(conceptId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/monitor-concepts/{concept_id}", {
+        params: { path: { workspace_id: this.workspaceId, concept_id: conceptId } }
+      })
+    );
+  }
+  /** Update a monitor concept */
+  async update(conceptId, body) {
+    return extractData(
+      await this.client.PATCH("/v1/{workspace_id}/monitor-concepts/{concept_id}", {
+        params: { path: { workspace_id: this.workspaceId, concept_id: conceptId } },
+        body
+      })
+    );
+  }
+  /** Delete a monitor concept */
+  async delete(conceptId) {
+    return extractData(
+      await this.client.DELETE("/v1/{workspace_id}/monitor-concepts/{concept_id}", {
+        params: { path: { workspace_id: this.workspaceId, concept_id: conceptId } }
+      })
+    );
+  }
+};
+
+// src/resources/unification-rules.ts
+var UnificationRulesResource = class extends WorkspaceScopedResource {
+  /** Create a new unification rule */
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/unification-rules", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  /** List unification rules in the workspace */
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/unification-rules", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  listAutoPaging(params) {
+    return this.iteratePaginatedList((pageParams) => this.list(pageParams), params);
+  }
+  /** Get a single unification rule */
+  async get(ruleId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/unification-rules/{rule_id}", {
+        params: { path: { workspace_id: this.workspaceId, rule_id: ruleId } }
+      })
+    );
+  }
+  /** Update a unification rule */
+  async update(ruleId, body) {
+    return extractData(
+      await this.client.PATCH("/v1/{workspace_id}/unification-rules/{rule_id}", {
+        params: { path: { workspace_id: this.workspaceId, rule_id: ruleId } },
+        body
+      })
+    );
+  }
+  /** Delete a unification rule */
+  async delete(ruleId) {
+    return extractData(
+      await this.client.DELETE("/v1/{workspace_id}/unification-rules/{rule_id}", {
+        params: { path: { workspace_id: this.workspaceId, rule_id: ruleId } }
+      })
+    );
+  }
+};
+
+// src/resources/crm.ts
+var CrmResource = class extends WorkspaceScopedResource {
+  /** Health/status of the workspace's CRM integration sync */
+  async getStatus() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/status", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  contacts = {
+    list: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/contacts", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    get: async (contactId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/contacts/{contact_id}", {
+        params: { path: { workspace_id: this.workspaceId, contact_id: contactId } }
+      })
+    ),
+    /** Per-contact activity timeline (calls, emails, deal events) */
+    getTimeline: async (contactId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/contacts/{contact_id}/timeline", {
+        params: { path: { workspace_id: this.workspaceId, contact_id: contactId } }
+      })
+    )
+  };
+  companies = {
+    list: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/companies", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    get: async (companyId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/companies/{company_id}", {
+        params: { path: { workspace_id: this.workspaceId, company_id: companyId } }
+      })
+    )
+  };
+  deals = {
+    list: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/deals", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    get: async (dealId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/deals/{deal_id}", {
+        params: { path: { workspace_id: this.workspaceId, deal_id: dealId } }
+      })
+    ),
+    /** Aggregated pipeline view: deals grouped by stage with rolled-up totals */
+    getPipeline: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/crm/deals/pipeline", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    )
+  };
+};
+
+// src/resources/command-center.ts
+var CommandCenterResource = class extends WorkspaceScopedResource {
+  /** Get the current command-center snapshot */
+  async get() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/command-center", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+};
+
+// src/resources/sensorium.ts
+var SensoriumResource = class extends WorkspaceScopedResource {
+  /** Per-connector health snapshot (status + latency) */
+  async getConnectorHealth() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/sensorium/connector-health", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** End-to-end agent loop latency breakdown (per-stage timings) */
+  async getLoopLatency() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/sensorium/loop-latency", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+};
+
+// src/resources/data-query.ts
+var DataQueryResource = class extends WorkspaceScopedResource {
+  /** Run a tabular query against a workspace dataset */
+  async run(schema, table, params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/query/{schema}/{table}", {
+        params: {
+          path: { workspace_id: this.workspaceId, schema, table },
+          query: params
+        }
+      })
+    );
+  }
+};
+
+// src/resources/briefs.ts
+var BriefsResource = class extends WorkspaceScopedResource {
+  /** Get the workspace-level brief */
+  async get() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/brief", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Regenerate the workspace-level brief */
+  async regenerate() {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/brief", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Get the brief for a specific entity */
+  async getForEntity(entityId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/entities/{entity_id}/brief", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
+  }
+  /** Regenerate the brief for a specific entity */
+  async regenerateForEntity(entityId2) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/entities/{entity_id}/brief", {
+        params: { path: { workspace_id: this.workspaceId, entity_id: entityId2 } }
+      })
+    );
+  }
+};
+
+// src/resources/desktop-sessions.ts
+var DesktopSessionsResource = class extends WorkspaceScopedResource {
+  /** Spin up a new desktop session */
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/desktop-sessions", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  /** Disconnect / tear down a desktop session */
+  async disconnect(sessionId) {
+    return extractData(
+      await this.client.DELETE("/v1/{workspace_id}/desktop-sessions/{session_id}", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } }
+      })
+    );
+  }
+  /** Drive a click / type / scroll action against the session */
+  async sendAction(sessionId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/desktop-sessions/{session_id}/action", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } },
+        body
+      })
+    );
+  }
+  /** Get the latest screenshot for a session */
+  async getScreenshot(sessionId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/desktop-sessions/{session_id}/screenshot", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } }
+      })
+    );
+  }
+  /** Get the session's current connection + activity status */
+  async getStatus(sessionId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/desktop-sessions/{session_id}/status", {
+        params: { path: { workspace_id: this.workspaceId, session_id: sessionId } }
+      })
+    );
+  }
+};
+
+// src/resources/intake.ts
+var IntakeResource = class extends WorkspaceScopedResource {
+  links = {
+    list: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/intake/links", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    create: async (body) => extractData(
+      await this.client.POST("/v1/{workspace_id}/intake/links", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    ),
+    delete: async (linkId) => extractData(
+      await this.client.DELETE("/v1/{workspace_id}/intake/links/{link_id}", {
+        params: { path: { workspace_id: this.workspaceId, link_id: linkId } }
+      })
+    ),
+    /** List uploads received against a link */
+    listUploads: async (linkId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/intake/links/{link_id}/uploads", {
+        params: { path: { workspace_id: this.workspaceId, link_id: linkId } }
+      })
+    ),
+    /** Get a download URL/payload for a single upload */
+    downloadUpload: async (linkId, uploadId) => extractData(
+      await this.client.GET(
+        "/v1/{workspace_id}/intake/links/{link_id}/uploads/{upload_id}/download",
+        {
+          params: {
+            path: {
+              workspace_id: this.workspaceId,
+              link_id: linkId,
+              upload_id: uploadId
+            }
+          }
+        }
+      )
+    )
+  };
+};
+
+// src/resources/network.ts
+var NetworkResource = class extends WorkspaceScopedResource {
+  /** Get the platform's egress IPs the workspace's outbound traffic uses */
+  async getEgressIps() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/network/egress-ips", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+};
+
+// src/resources/pipeline.ts
+var PipelineResource = class extends WorkspaceScopedResource {
+  /** Overall pipeline status (sources up/down, last successful run, etc.) */
+  async getStatus() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/status", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Throughput buckets over the recent window */
+  async getThroughput() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/throughput", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Review backlog metrics (pending merges, pending escalations) */
+  async getReview() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/review", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Entity resolution metrics (merge rate, candidate rate, false-positive rate) */
+  async getEntityResolution() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/entity-resolution", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  outbound = {
+    /** List recent outbound deliveries */
+    list: async () => extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/outbound", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    ),
+    /** Get the delivery log for a specific outbound data source */
+    getLog: async (dataSourceId2, params) => extractData(
+      await this.client.GET(
+        "/v1/{workspace_id}/pipeline/outbound/{data_source_id}/log",
+        {
+          params: {
+            path: { workspace_id: this.workspaceId, data_source_id: dataSourceId2 },
+            query: params
+          }
+        }
+      )
+    )
+  };
+  sources = {
+    /** List all configured pipeline sources */
+    list: async (params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/sources", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    ),
+    /** Get a per-source overview (last sync, error counts, deltas) */
+    getOverview: async (sourceId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/sources/{source_id}/overview", {
+        params: { path: { workspace_id: this.workspaceId, source_id: sourceId } }
+      })
+    ),
+    /** Stream the source's recent events */
+    listEvents: async (sourceId, params) => extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/sources/{source_id}/events", {
+        params: {
+          path: { workspace_id: this.workspaceId, source_id: sourceId },
+          query: params
+        }
+      })
+    ),
+    /** Per-source historical timeline */
+    getHistory: async (sourceId) => extractData(
+      await this.client.GET("/v1/{workspace_id}/pipeline/sources/{source_id}/history", {
+        params: { path: { workspace_id: this.workspaceId, source_id: sourceId } }
+      })
+    )
+  };
+};
+
+// src/resources/tasks.ts
+var TasksResource = class extends WorkspaceScopedResource {
+  /** Get the current state of a single task */
+  async get(taskId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/tasks/{task_id}", {
+        params: { path: { workspace_id: this.workspaceId, task_id: taskId } }
+      })
+    );
+  }
+  /** List every task associated with a call (by Twilio call sid) */
+  async listByCall(callSid) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/tasks/by-call/{call_sid}", {
+        params: { path: { workspace_id: this.workspaceId, call_sid: callSid } }
+      })
+    );
+  }
+};
+
+// src/resources/tools.ts
+var ToolsResource = class extends WorkspaceScopedResource {
+  /** Manually execute a tool call against the workspace's integrations */
+  async execute(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/tools/execute", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  /** Resolve the bound tool implementations for a service */
+  async resolveForService(serviceId2) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/services/{service_id}/tools/resolve", {
+        params: { path: { workspace_id: this.workspaceId, service_id: serviceId2 } }
+      })
+    );
+  }
+};
+
+// src/resources/surfaces.ts
+var SurfacesResource = class extends WorkspaceScopedResource {
+  /** List surfaces in the workspace */
+  async list(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/surfaces", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  listAutoPaging(params) {
+    return this.iteratePaginatedList((pageParams) => this.list(pageParams), params);
+  }
+  /** Surfaces awaiting review (pending approval / rejection) */
+  async listForReview(params) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/surfaces/review", {
+        params: { path: { workspace_id: this.workspaceId }, query: params }
+      })
+    );
+  }
+  /** Create a surface (form definition + delivery config) */
+  async create(body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/surfaces", {
+        params: { path: { workspace_id: this.workspaceId } },
+        body
+      })
+    );
+  }
+  /** Get a single surface */
+  async get(surfaceId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/surfaces/{surface_id}", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } }
+      })
+    );
+  }
+  /** Update surface metadata or fields */
+  async update(surfaceId, body) {
+    return extractData(
+      await this.client.PATCH("/v1/{workspace_id}/surfaces/{surface_id}", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } },
+        body
+      })
+    );
+  }
+  /** Archive (soft-delete) a surface */
+  async archive(surfaceId) {
+    return extractData(
+      await this.client.DELETE("/v1/{workspace_id}/surfaces/{surface_id}", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } }
+      })
+    );
+  }
+  /** Deliver the surface to the recipient (SMS/email/etc.) */
+  async deliver(surfaceId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/surfaces/{surface_id}/deliver", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } },
+        body
+      })
+    );
+  }
+  /** Get fill / completion progress for a surface */
+  async getProgress(surfaceId) {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/surfaces/{surface_id}/progress", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } }
+      })
+    );
+  }
+  /** Approve a pending-review surface */
+  async approve(surfaceId) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/surfaces/{surface_id}/approve", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } }
+      })
+    );
+  }
+  /** Reject a pending-review surface */
+  async reject(surfaceId, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/surfaces/{surface_id}/reject", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } },
+        body
+      })
+    );
+  }
+  /** Reshape — clone the surface with refined fields (review redirect) */
+  async reshape(surfaceId) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/surfaces/{surface_id}/reshape", {
+        params: { path: { workspace_id: this.workspaceId, surface_id: surfaceId } }
+      })
+    );
+  }
+};
+
+// src/resources/sessions.ts
+var SessionsResource = class extends WorkspaceScopedResource {
+  /** List currently active sessions across the workspace */
+  async listActive() {
+    return extractData(
+      await this.client.GET("/v1/{workspace_id}/sessions/active", {
+        params: { path: { workspace_id: this.workspaceId } }
+      })
+    );
+  }
+  /** Inject a one-shot directive (text/audio) into a live call session */
+  async inject(callSid, body) {
+    return extractData(
+      await this.client.POST("/v1/{workspace_id}/sessions/{call_sid}/inject", {
+        params: { path: { workspace_id: this.workspaceId, call_sid: callSid } },
+        body
+      })
+    );
+  }
+};
+
 // src/core/branded-types.ts
 var workspaceId = (id) => id;
 var apiKeyId = (id) => id;
@@ -4958,6 +5970,40 @@ var AmigoClient = class _AmigoClient {
    * {@link ObserversResource}.
    */
   observers;
+  /** FHIR / EHR data interop — sync status, imports, resources, patient views */
+  fhir;
+  /** Natural-language insights — schema, suggestions, SQL, chat sessions */
+  insights;
+  /** Workspace monitor concepts (semantic patterns watched across calls) */
+  monitorConcepts;
+  /** Entity unification rules (declarative deduplication of world-model entities) */
+  unificationRules;
+  /** CRM — contacts, companies, deals, pipeline (sync from connected CRM integration) */
+  crm;
+  /** Command Center — rolled-up workspace homepage snapshot */
+  commandCenter;
+  /** Sensorium — operator-facing live agent loop observability */
+  sensorium;
+  /** Generic data query against whitelisted workspace datasets */
+  dataQuery;
+  /** AI-generated entity briefs (workspace-level + per-entity) */
+  briefs;
+  /** Remote-controlled desktop sessions for driving GUI-only third-party apps */
+  desktopSessions;
+  /** Patient intake — signed upload links + uploads */
+  intake;
+  /** Workspace network metadata (egress IP allowlist) */
+  network;
+  /** Data ingestion pipeline observability (sources, throughput, review backlog) */
+  pipeline;
+  /** Long-running async tasks (poll by id or list by call) */
+  tasks;
+  /** Manual tool execution + per-service tool resolution */
+  tools;
+  /** Surfaces — short-lived form/intake experiences (lifecycle: create→deliver→review→approve) */
+  surfaces;
+  /** Live agent sessions — list active calls + inject mid-call directives */
+  sessions;
   /** @internal — exposed for path-level type inference in GET/POST/PUT/etc. */
   api;
   constructor(config) {
@@ -5059,6 +6105,23 @@ var AmigoClient = class _AmigoClient {
     mutable.events = new EventsResource(client, workspaceId2);
     mutable.functions = new FunctionsResource(client, workspaceId2);
     mutable.observers = new ObserversResource(client, workspaceId2, agentBaseUrl);
+    mutable.fhir = new FhirResource(client, workspaceId2);
+    mutable.insights = new InsightsResource(client, workspaceId2);
+    mutable.monitorConcepts = new MonitorConceptsResource(client, workspaceId2);
+    mutable.unificationRules = new UnificationRulesResource(client, workspaceId2);
+    mutable.crm = new CrmResource(client, workspaceId2);
+    mutable.commandCenter = new CommandCenterResource(client, workspaceId2);
+    mutable.sensorium = new SensoriumResource(client, workspaceId2);
+    mutable.dataQuery = new DataQueryResource(client, workspaceId2);
+    mutable.briefs = new BriefsResource(client, workspaceId2);
+    mutable.desktopSessions = new DesktopSessionsResource(client, workspaceId2);
+    mutable.intake = new IntakeResource(client, workspaceId2);
+    mutable.network = new NetworkResource(client, workspaceId2);
+    mutable.pipeline = new PipelineResource(client, workspaceId2);
+    mutable.tasks = new TasksResource(client, workspaceId2);
+    mutable.tools = new ToolsResource(client, workspaceId2);
+    mutable.surfaces = new SurfacesResource(client, workspaceId2);
+    mutable.sessions = new SessionsResource(client, workspaceId2);
   }
   async resolveApiRequest(path, method, init) {
     const { baseClient, options } = resolveScopedPlatformClient(this.api);