slotlock 0.7.0 → 0.9.0

package/approvals.d.ts

@@ -23,6 +23,8 @@ export interface PutApprovalPolicyParams {
     outcome: SlotlockApprovalPolicy['outcome'];
     approvalTtlMinutes?: number;
     leadMinutes?: number;
+    /** It also holds the tenant's own bookings through the application API (default false). */
+    includeApplication?: boolean;
 }
 /** Create or replace a policy by its reference. Throws `invalid_approval_policy`; at most 50. */
 export declare function putApprovalPolicy(sql: StoreSql, params: PutApprovalPolicyParams): Promise<SlotlockApprovalPolicy | null>;

package/approvals.js

@@ -18,7 +18,7 @@ export class SlotlockApprovalPolicyError extends Error {
         super(`Slotlock approval policy: ${message}`);
     }
 }
-const POLICY_COLUMNS = 'ref, name, applies_to, conditions, outcome, approval_ttl_minutes, lead_minutes, created_at, updated_at';
+const POLICY_COLUMNS = 'ref, name, applies_to, conditions, outcome, approval_ttl_minutes, lead_minutes, include_application, created_at, updated_at';
 function toPolicy(row) {
     const applies = row.applies_to;
     const conditions = row.conditions;
@@ -39,6 +39,7 @@ function toPolicy(row) {
         outcome: row.outcome,
         approvalTtlMinutes: row.approval_ttl_minutes,
         leadMinutes: row.lead_minutes,
+        includeApplication: row.include_application === true,
         createdAt: row.created_at,
         updatedAt: row.updated_at,
     };
@@ -99,24 +100,30 @@ function storedPolicy(params) {
         ...(given.outsideHours !== undefined ? { outside_hours: given.outsideHours } : {}),
         ...(given.kinds !== undefined ? { kinds: [...new Set(given.kinds)].sort() } : {}),
     };
-    return { name, appliesTo, conditions, ttl, lead };
+    if (params.includeApplication !== undefined && typeof params.includeApplication !== 'boolean') {
+        throw new SlotlockApprovalPolicyError('include_application must be true or false');
+    }
+    return { name, appliesTo, conditions, ttl, lead, includeApplication: params.includeApplication === true };
 }
 /** Create or replace a policy by its reference. Throws `invalid_approval_policy`; at most 50. */
 export async function putApprovalPolicy(sql, params) {
     const stored = storedPolicy(params);
     const [row] = await sql `
     INSERT INTO slotlock.approval_policies (
-      tenant_ref, ref, name, applies_to, conditions, outcome, approval_ttl_minutes, lead_minutes
+      tenant_ref, ref, name, applies_to, conditions, outcome, approval_ttl_minutes, lead_minutes,
+      include_application
     )
     SELECT ${params.tenantRef}, ${params.ref}, ${stored.name}, ${sql.json(stored.appliesTo)},
-           ${sql.json(stored.conditions)}, ${params.outcome}, ${stored.ttl}, ${stored.lead}
+           ${sql.json(stored.conditions)}, ${params.outcome}, ${stored.ttl}, ${stored.lead},
+           ${stored.includeApplication}
      WHERE EXISTS (SELECT 1 FROM slotlock.approval_policies WHERE tenant_ref = ${params.tenantRef} AND ref = ${params.ref})
         OR (SELECT count(*) FROM slotlock.approval_policies WHERE tenant_ref = ${params.tenantRef})
            < ${SLOTLOCK_MAX_APPROVAL_POLICIES}
     ON CONFLICT (tenant_ref, ref) DO UPDATE
       SET name = EXCLUDED.name, applies_to = EXCLUDED.applies_to, conditions = EXCLUDED.conditions,
           outcome = EXCLUDED.outcome, approval_ttl_minutes = EXCLUDED.approval_ttl_minutes,
-          lead_minutes = EXCLUDED.lead_minutes, updated_at = statement_timestamp()
+          lead_minutes = EXCLUDED.lead_minutes, include_application = EXCLUDED.include_application,
+          updated_at = statement_timestamp()
     RETURNING ${sql.unsafe(POLICY_COLUMNS)}`;
     return row ? toPolicy(row) : null;
 }

package/assistant.d.ts

@@ -1,5 +1,5 @@
 import { type SlotlockAgentOperation } from './agent-server.js';
-import type { SlotlockAssistantConversationRecord, SlotlockAssistantSettingsRecord, SlotlockStore } from './store.js';
+import type { SlotlockAssistantChatRecord, SlotlockAssistantChatSummary, SlotlockAssistantSettingsRecord, SlotlockStore } from './store.js';
 export type SlotlockAssistantProvider = 'anthropic' | 'openai';
 /** What the assistant does with each agent operation: run it, propose it, or never offer it. */
 export type SlotlockAssistantToolUse = 'read' | 'propose' | 'excluded';
@@ -95,18 +95,27 @@ export interface SlotlockAssistantStore {
      * still opens, and is opened that way each time.
      */
     resealKey?(tenantRef: string, from: string, to: string): Promise<boolean>;
-    getConversation(tenantRef: string, memberRef: string): Promise<SlotlockAssistantConversationRecord | null>;
+    /** A member's conversations, the most recent first: what the Chats list shows. */
+    listChats(tenantRef: string, memberRef: string, limit?: number): Promise<SlotlockAssistantChatSummary[]>;
+    /** One of a member's conversations, or null when there is none by that id. */
+    getChat(tenantRef: string, memberRef: string, chatId: string): Promise<SlotlockAssistantChatRecord | null>;
     /**
-     * Replace a member's messages; keep the stored actions `keep` names, as they stand, and add the
-     * `added` ones not stored already (store.ts putAssistantConversation).
+     * Create one of a member's conversations (titled `title`), or replace its messages; keep the
+     * stored actions `keep` names, as they stand, and add the `added` ones not stored already
+     * (store.ts putAssistantChat). Kept until deleted, or for `ttlMs` when given. With `create`
+     * false, only one still there is changed (false when it was deleted meanwhile).
      */
-    putConversation(tenantRef: string, memberRef: string, conversation: {
+    putChat(tenantRef: string, memberRef: string, chatId: string, chat: {
+        title: string;
         messages: unknown[];
         added: Record<string, Record<string, unknown>>;
         keep: readonly string[];
-    }, ttlMs: number): Promise<void>;
-    settleAction(tenantRef: string, memberRef: string, actionId: string, from: string, patch: Record<string, unknown>): Promise<Record<string, unknown> | null>;
-    deleteConversation(tenantRef: string, memberRef: string): Promise<boolean>;
+        create?: boolean;
+    }, ttlMs: number | null): Promise<boolean>;
+    /** Give a conversation a new title (1-120 characters). False when there is none. */
+    renameChat(tenantRef: string, memberRef: string, chatId: string, title: string): Promise<boolean>;
+    settleAction(tenantRef: string, memberRef: string, chatId: string, actionId: string, from: string, patch: Record<string, unknown>): Promise<Record<string, unknown> | null>;
+    deleteChat(tenantRef: string, memberRef: string, chatId: string): Promise<boolean>;
 }
 /** The assistant's records in the store, each in a transaction under the tenant's row-level security. */
 export declare function createSlotlockAssistantStore(store: SlotlockStore): SlotlockAssistantStore;
@@ -191,6 +200,11 @@ interface ModelRequest {
     force?: string;
     fetch: typeof fetch;
     signal: AbortSignal;
+    /**
+     * Stream the answer: called with each piece of its text as it arrives, in order; the pieces join
+     * to the answer's text. Without it the call asks for one JSON answer.
+     */
+    onText?: (delta: string) => void;
 }
 /** One model call. Throws SlotlockAssistantProviderError, whose message never holds the key. */
 export declare function callSlotlockAssistantModel(request: ModelRequest): Promise<SlotlockAssistantModelTurn>;
@@ -257,7 +271,30 @@ export interface SlotlockAssistantTurnOptions {
         ok: false;
         code: string;
     }>;
+    /** Stream the turn: each model call's text as it arrives, and each tool call before and after it runs. */
+    onEvent?: (event: SlotlockAssistantTurnEvent) => void;
+    /** The member's Stop: the turn ends at once, keeping what it has, and says it stopped. */
+    signal?: AbortSignal;
 }
+/**
+ * What a streamed turn tells as it goes, in order: text as the model writes it; then each tool call
+ * (`read` runs, `write` is proposed, `unknown` is refused) before it runs, and its result after.
+ */
+export type SlotlockAssistantTurnEvent = {
+    type: 'text';
+    delta: string;
+} | {
+    type: 'call';
+    id: string;
+    name: string;
+    use: 'read' | 'write' | 'unknown';
+} | {
+    type: 'result';
+    id: string;
+    name: string;
+    ok: boolean;
+    actionId?: string;
+};
 export interface SlotlockAssistantTurnResult {
     /** The entries this turn added. */
     added: SlotlockAssistantEntry[];
@@ -267,7 +304,8 @@ export interface SlotlockAssistantTurnResult {
 /**
  * One member message: call the model, run what it reads, keep what it would write, and call it
  * again with the results, up to `maxSteps` calls. Only the offered tools run, whatever the model
- * names; everything else is answered `tool_not_available`.
+ * names; everything else is answered `tool_not_available`. With `onEvent` each model call streams;
+ * once `signal` aborts, no model call or tool goes on, and every call kept has its result.
  */
 export declare function runSlotlockAssistantTurn(options: SlotlockAssistantTurnOptions): Promise<SlotlockAssistantTurnResult>;
 /**
@@ -284,11 +322,28 @@ export declare function pruneSlotlockAssistantActions(entries: readonly Slotlock
 export declare function pendingSlotlockAssistantActions(actions: Readonly<Record<string, Record<string, unknown>>>): number;
 /** Read stored entries back, dropping anything malformed. */
 export declare function readSlotlockAssistantEntries(value: unknown): SlotlockAssistantEntry[];
+/** A resource as the assistant's system prompt lists it: its id, and what people call it. */
+export interface SlotlockAssistantResourceEntry {
+    id: string;
+    name?: string;
+    ref?: string;
+    kind?: string;
+    location?: string;
+    timezone: string;
+}
+/** How many of the workspace's resources the system prompt lists; the rest are found by search. */
+export declare const SLOTLOCK_ASSISTANT_DIRECTORY_SIZE = 50;
 /** The system prompt: who the model works for, and that what it reads is data, not instructions. */
 export declare function slotlockAssistantSystemPrompt(args: {
     brand: string;
     workspace: string;
     login: string;
     now: Date;
+    /**
+     * The workspace's resources agents may see, so a resource the member names is matched to its id
+     * without a lookup; `resourceCount` is how many there are when that is more than are listed.
+     */
+    resources?: readonly SlotlockAssistantResourceEntry[];
+    resourceCount?: number;
 }): string;
 export {};