@proteos/sdk 0.39.0 → 0.40.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proteos/sdk",
-  "version": "0.39.0",
+  "version": "0.40.0",
   "license": "Apache-2.0",
   "description": "TypeScript SDK for the Proteos platform",
   "repository": {

package/src/agent/index.ts

@@ -132,6 +132,7 @@ export type {
   SkillVersion,
   StartMcpOAuthResponse,
   PlatformBinding,
+  QueryBinding,
   Tool,
   ToolBinding,
   ToolKind,

package/src/agent/session-types.ts

@@ -224,8 +224,15 @@ export interface StopReason {
 }
 
 /**
- * Emitted when a turn ends. `event_ids` carries the tool_use event ids awaiting a
- * client response when `stop_reason.type` is `user_action_required`.
+ * Ends a turn — published once per turn by the server, not an echo of the upstream
+ * provider's session status (which flips idle/running once per server-side tool
+ * round, mid-turn).
+ *
+ * `event_ids` is set only with `stop_reason.type: 'user_action_required'`, and lists
+ * the tool_use events still OUTSTANDING — the ones a client must answer. Tools the
+ * server executes itself are resolved before this event exists, so seeing this event
+ * at all means the turn cannot continue without you: answer each id with a
+ * `user.tool_result`.
  */
 export interface SessionIdlePayload {
   stop_reason: StopReason

package/src/agent/types.ts

@@ -217,8 +217,10 @@ export type ListSkillsOptions = AgentResourceListOptions
  * - `client` is a host-provided builtin and carries no binding.
  * - `platform` binds to one tool of the platform MCP server (mcp-service),
  *   executed server-side as the acting user.
+ * - `query` stores a SQL query with declared params, executed server-side
+ *   against data-service as the acting user.
  */
-export type ToolKind = 'action' | 'mcp' | 'client' | 'platform'
+export type ToolKind = 'action' | 'mcp' | 'client' | 'platform' | 'query'
 
 /** Binds to a function-service Action by its key (kind=action). */
 export interface ActionBinding {
@@ -240,8 +242,19 @@ export interface PlatformBinding {
   tool_name: string
 }
 
+/**
+ * Stores a SELECT-only SQL query (data-service dialect) whose `{{param}}`
+ * placeholders are filled from the declared `params` at execution time
+ * (kind=query). Params are scalar attribute definitions (string, number,
+ * integer, boolean, datetime, enum); they generate the tool's input schema.
+ */
+export interface QueryBinding {
+  sql: string
+  params?: Attribute[]
+}
+
 /** Kind-discriminated binding payload. `kind=client` carries no binding. */
-export type ToolBinding = ActionBinding | McpBinding | PlatformBinding
+export type ToolBinding = ActionBinding | McpBinding | PlatformBinding | QueryBinding
 
 /**
  * A thin registry entry over one of three binding sources. `key` is the wire

package/src/conversation/index.ts

@@ -19,6 +19,7 @@ import type {
   CreateConversationTypeRequest,
   CreateGlossaryTermRequest,
   CreateTranscriptionRequest,
+  DeleteConnectionQuery,
   DispatchMeetingBotRequest,
   GlossaryTerm,
   InstallConnectionResponse,
@@ -164,7 +165,14 @@ export interface ConnectionService {
   get(id: string): Promise<Connection>
   create(request: CreateConnectionRequest): Promise<Connection>
   update(id: string, request: UpdateConnectionRequest): Promise<Connection>
-  delete(id: string): Promise<void>
+  /**
+   * Delete a connection. The connector first releases its provider-side
+   * registration (a Recall calendar and the OAuth grant behind it); when that
+   * fails the delete is refused with a `connector_uninstall_failed` 502 rather
+   * than orphaning it. Pass `{ is_forced: true }` to drop the row anyway and
+   * clean up at the provider by hand.
+   */
+  delete(id: string, query?: DeleteConnectionQuery): Promise<void>
   /** Begin the connector's install flow; open the returned URL in a popup. */
   install(id: string): Promise<InstallConnectionResponse>
   /**
@@ -211,10 +219,11 @@ class ConnectionServiceImpl implements ConnectionService {
     )
   }
 
-  async delete(id: string): Promise<void> {
-    await this.client.request(
+  async delete(id: string, query: DeleteConnectionQuery = {}): Promise<void> {
+    await this.client.requestWithQuery(
       'DELETE',
       `${CONVERSATION_BASE_PATH}/connections/${encodeURIComponent(id)}`,
+      query,
     )
   }
 
@@ -392,6 +401,11 @@ export interface ConversationService {
   /** Patch the user-editable surface (subject, summary, status, metadata). */
   update(id: string, request: UpdateConversationRequest): Promise<Conversation>
   end(id: string): Promise<Conversation>
+  /**
+   * Hard-delete the conversation, its thread children, and every dependent
+   * row (messages, attachments, read markers, transcriptions). Irreversible.
+   */
+  delete(id: string): Promise<void>
   /** Upsert the requesting user's read marker to now (open a conversation). */
   markRead(id: string): Promise<void>
   /** Remove the marker — the conversation reads as unread again. */
@@ -429,6 +443,13 @@ class ConversationServiceImpl implements ConversationService {
     )
   }
 
+  delete(id: string): Promise<void> {
+    return this.client.request(
+      'DELETE',
+      `${CONVERSATION_BASE_PATH}/conversations/${encodeURIComponent(id)}`,
+    )
+  }
+
   markRead(id: string): Promise<void> {
     return this.client.request(
       'POST',

package/src/conversation/types.ts

@@ -730,6 +730,17 @@ export interface ListConnectionsQuery extends PaginationQuery {
   status?: string
 }
 
+/**
+ * The delete's escape hatch. A connection delete makes the connector release
+ * its provider-side registration first and refuses with a 502
+ * `connector_uninstall_failed` when that fails — the row is the only handle on
+ * that state. `is_forced` drops the row anyway, leaving the provider-side
+ * leftovers as a manual cleanup.
+ */
+export interface DeleteConnectionQuery {
+  is_forced?: boolean
+}
+
 export interface ListConversationsQuery extends PaginationQuery {
   channel?: string
   status?: string
@@ -783,18 +794,33 @@ export interface ListAgentListenersQuery extends PaginationQuery {
 }
 
 /**
- * Conversation filters: ingest-time rules that drop matching inbound messages
- * BEFORE persistence (no message, no contact — only a content-free audit
- * event). Scope-first evaluation: connection-scoped rules are final when one
- * matches; global rules apply otherwise. Specificity within a scope:
- * address > domain > role_based > automated > internal_conversations > all,
- * allow beats block within a class.
+ * Conversation filters: rules that drop matching inbound messages BEFORE
+ * persistence (no message, no contact — only a content-free audit event) and,
+ * on meeting calendar connections, gate whether the meeting bot is scheduled
+ * at all (pre-join enforcement of the same rules — earliest possible point).
+ * Scope-first evaluation: connection-scoped rules are final when one matches;
+ * global rules apply otherwise. Specificity within a scope:
+ * address > domain > title_keyword > role_based > automated >
+ * self_originated > internal_participant > internal_conversations > all,
+ * allow beats block within a class; an allow match is a final keep, which is
+ * the auto-join composition mechanism (e.g. "organized by me" = a
+ * connection-scoped all-block plus a self_originated allow).
+ *
+ * Channel matrix: address/self_originated/all act on every channel;
+ * domain/title_keyword/internal_participant/internal_conversations act on
+ * email + meeting connections; role_based/automated are email-only. A
+ * connection-scoped rule of a type inert on that connection's channel is
+ * rejected (invalid_filter_config); global rules are unrestricted and stay
+ * inert where their facts are missing.
  */
 export type ConversationFilterType =
   | 'address'
   | 'domain'
+  | 'title_keyword'
   | 'role_based'
   | 'automated'
+  | 'self_originated'
+  | 'internal_participant'
   | 'internal_conversations'
   | 'all'
 export type ConversationFilterAction = 'block' | 'allow'
@@ -827,6 +853,16 @@ export interface RoleBasedFilterConfig {
 export interface AutomatedFilterConfig {
   signals?: AutomatedSignal[]
 }
+/** Title/subject contains any keyword (case-insensitive substring; stored lowercased). */
+export interface TitleKeywordFilterConfig {
+  keywords: string[]
+}
+/** Conversation originates from the connection owner (meeting organizer / self sender). Empty config. */
+export type SelfOriginatedFilterConfig = Record<string, never>
+/** ≥1 participant OTHER than the connection self is on one of these domains (any-internal). */
+export interface InternalParticipantFilterConfig {
+  domains: string[]
+}
 /** Drops only when sender AND every recipient are on these domains. Always block. */
 export interface InternalConversationsFilterConfig {
   domains: string[]
@@ -837,8 +873,11 @@ export type AllFilterConfig = Record<string, never>
 export type ConversationFilterConfig =
   | AddressFilterConfig
   | DomainFilterConfig
+  | TitleKeywordFilterConfig
   | RoleBasedFilterConfig
   | AutomatedFilterConfig
+  | SelfOriginatedFilterConfig
+  | InternalParticipantFilterConfig
   | InternalConversationsFilterConfig
   | AllFilterConfig
 

package/src/index.ts

@@ -100,6 +100,7 @@ export type {
   StopReason,
   TextBlock,
   PlatformBinding,
+  QueryBinding,
   Tool,
   ToolBinding,
   ToolConfirmationPayload,