@squidcloud/cli 1.0.416 → 1.0.418

package/dist/index.js

@@ -11394,6 +11394,7 @@ exports.CONNECTOR_IDS = [
     'salesforce',
     'servicenow',
     'slack',
+    'teams',
     'zendesk',
 ];
 /** A file inside a connector package that contains package metadata. */
@@ -14187,7 +14188,7 @@ function setupDeployCommand(yargs) {
             (0, process_utils_1.exitWithError)('Must provide an API key');
         const appRegion = geAppRegionFromCommandOrEnv(argv.region);
         const consoleRegion = geConsoleRegionFromCommandOrEnv(argv.consoleRegion) || getConsoleRegionFromAppRegion(appRegion);
-        (0, deploy_1.deploy)(consoleRegion, appId, bundlePath, apiKey, !!argv.verbose, argv.direct, isUserSpecifiedPath, !!argv.skipBuild, internalApiKey, environmentId).then();
+        void (0, deploy_1.deploy)(consoleRegion, appId, bundlePath, apiKey, !!argv.verbose, argv.direct, isUserSpecifiedPath, !!argv.skipBuild, internalApiKey, environmentId);
     });
 }
 function setupUndeployCommand(yargs) {
@@ -14208,7 +14209,7 @@ function setupUndeployCommand(yargs) {
         const environmentId = getEnvironmentIdFromCommandOrEnv(argv.environmentId);
         const region = geAppRegionFromCommandOrEnv(undefined);
         const consoleRegion = geConsoleRegionFromCommandOrEnv(argv.consoleRegion) || getConsoleRegionFromAppRegion(region);
-        (0, undeploy_1.undeploy)(consoleRegion, appId, apiKey, environmentId).then();
+        void (0, undeploy_1.undeploy)(consoleRegion, appId, apiKey, environmentId);
     });
 }
 function setupInitEnvCommand(yargs) {
@@ -23431,6 +23432,7 @@ exports.INTEGRATION_TYPES = [
     'mcp',
     'a2a',
     'legend',
+    'teams',
     'ollama',
 ];
 /**
@@ -25073,6 +25075,7 @@ exports.OPENAI_CHAT_MODEL_NAMES = [
     'gpt-5',
     'gpt-5-mini',
     'gpt-5-nano',
+    'gpt-5.1',
     'gpt-4.1',
     'gpt-4.1-mini',
     'gpt-4.1-nano',
@@ -30556,7 +30559,7 @@ function exitWithError(...messages) {
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@squidcloud/cli","version":"1.0.416","description":"The Squid CLI","main":"dist/index.js","scripts":{"start":"node dist/index.js","start-ts":"ts-node -r tsconfig-paths/register src/index.ts","prebuild":"rimraf dist","build":"webpack --mode=production","build:dev":"webpack --mode=development","lint":"eslint","link":"npm run build && chmod 755 dist/index.js && npm link","watch":"webpack --watch","deploy":"npm run build && npm pack --silent | xargs -I {} mv {} package.tgz && npm install -g package.tgz && rm -rf package.tgz","publish:public":"npm run build && npm publish --access public"},"files":["dist/**/*"],"bin":{"squid":"dist/index.js"},"keywords":[],"author":"","license":"ISC","engines":{"node":">=18.0.0"},"dependencies":{"@squidcloud/local-backend":"^1.0.416","adm-zip":"^0.5.16","copy-webpack-plugin":"^12.0.2","decompress":"^4.2.1","nodemon":"^3.1.9","terser-webpack-plugin":"^5.3.10","ts-loader":"^9.5.1","ts-node":"^10.9.2","tsconfig-paths":"^4.2.0","tsconfig-paths-webpack-plugin":"^4.1.0","webpack":"^5.101.3","zip-webpack-plugin":"^4.0.1"},"devDependencies":{"@types/adm-zip":"^0.5.7","@types/decompress":"^4.2.7","@types/node":"^20.19.9","terminal-link":"^3.0.0"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@squidcloud/cli","version":"1.0.418","description":"The Squid CLI","main":"dist/index.js","scripts":{"start":"node dist/index.js","start-ts":"ts-node -r tsconfig-paths/register src/index.ts","prebuild":"rimraf dist","build":"webpack --mode=production","build:dev":"webpack --mode=development","lint":"eslint","link":"npm run build && chmod 755 dist/index.js && npm link","watch":"webpack --watch","deploy":"npm run build && npm pack --silent | xargs -I {} mv {} package.tgz && npm install -g package.tgz && rm -rf package.tgz","publish:public":"npm run build && npm publish --access public"},"files":["dist/**/*"],"bin":{"squid":"dist/index.js"},"keywords":[],"author":"","license":"ISC","engines":{"node":">=18.0.0"},"dependencies":{"@squidcloud/local-backend":"^1.0.418","adm-zip":"^0.5.16","copy-webpack-plugin":"^12.0.2","decompress":"^4.2.1","nodemon":"^3.1.9","terser-webpack-plugin":"^5.3.10","ts-loader":"^9.5.1","ts-node":"^10.9.2","tsconfig-paths":"^4.2.0","tsconfig-paths-webpack-plugin":"^4.1.0","webpack":"^5.101.3","zip-webpack-plugin":"^4.0.1"},"devDependencies":{"@types/adm-zip":"^0.5.7","@types/decompress":"^4.2.7","@types/node":"^20.19.9","terminal-link":"^3.0.0"}}');
 
 /***/ }),
 

package/dist/resources/claude/skills/squid-development/SKILL.md

@@ -15,6 +15,235 @@ Squid is a backend-as-a-service platform that provides:
 - **CLI** (`@squidcloud/cli`) - Local development and deployment tools
 - **Built-in integrations** - Databases, queues, storage, AI, APIs
 
+## Squid Architecture: The Three Parts
+
+When developing with Squid, you work with three distinct but interconnected parts:
+
+### 1. Client (Frontend/External Services)
+
+**What it is:** Any application that needs to interact with your Squid backend - web apps, mobile apps, desktop apps, or even other servers.
+
+**How it works:**
+- Initializes the Squid Client SDK (`@squidcloud/client`)
+- Communicates with Squid functionality over HTTP/WebSocket
+- Can interact with AI agents, modify agent settings, query databases, call backend functions, etc.
+- Optionally uses authentication (OAuth2.0) for user-specific access
+- Respects security rules defined in the backend
+
+**Common use cases:**
+```typescript
+// Web/mobile application
+const squid = new Squid({
+  appId: 'your-app-id',
+  region: 'us-east-1.aws',
+  authProvider: { /* user auth */ }
+});
+
+// Interact with agents
+const agent = squid.ai().agent('support-agent');
+const response = await agent.ask('How do I reset my password?');
+
+// Query databases
+const users = await squid.collection('users').query().eq('active', true).snapshot();
+
+// Call backend functions
+const result = await squid.executeFunction('processPayment', paymentData);
+```
+
+**Key point:** Clients have limited, controlled access based on security rules you define in the backend.
+
+### 2. Squid Backend (Your Server-Side Code)
+
+**What it is:** TypeScript code that runs on Squid's infrastructure, containing your business logic, security rules, and integrations.
+
+**How it works:**
+- Contains services that extend `SquidService`
+- Uses **decorators** to define functionality:
+  - `@executable()` - Backend functions callable from clients
+  - `@webhook()` - HTTP endpoints for external services
+  - `@trigger()` - React to database changes
+  - `@scheduler()` - Run code on a schedule (cron jobs)
+  - `@secureDatabase()`, `@secureCollection()` - Define who can access data
+  - `@secureAiAgent()` - Control agent access
+  - `@aiFunction()` - Functions that AI agents can call
+  - And many more decorators for security, rate limiting, etc.
+- Has **full access** to all Squid functionality via pre-initialized `this.squid` client (with API key permissions)
+- Deployed to Squid infrastructure using `squid deploy`
+
+**Example backend service:**
+```typescript
+import { SquidService, executable, scheduler, trigger, secureCollection } from '@squidcloud/backend';
+
+export class MyService extends SquidService {
+  // Backend function callable from client
+  @executable()
+  async processPayment(amount: number, userId: string): Promise<PaymentResult> {
+    // Full access to Squid - this.squid has API key permissions
+    const user = await this.squid.collection('users').doc({ id: userId }).snapshot();
+
+    // Your business logic here
+    return { success: true, transactionId: '...' };
+  }
+
+  // React to database changes
+  @trigger({ id: 'new-user', collection: 'users', mutationTypes: ['insert'] })
+  async onNewUser(request: TriggerRequest<User>): Promise<void> {
+    await sendWelcomeEmail(request.docAfter);
+  }
+
+  // Scheduled task (cron job)
+  @scheduler({ id: 'daily-report', cron: '0 0 * * *' })
+  async generateDailyReport(): Promise<void> {
+    // Runs every day at midnight
+    const stats = await this.calculateStats();
+    await this.sendReport(stats);
+  }
+
+  // Security rule - who can read users collection
+  @secureCollection('users', 'read')
+  allowUserRead(context: QueryContext): boolean {
+    const userId = this.getUserAuth()?.userId;
+    // Only allow users to read their own data
+    return context.isSubqueryOf('id', '==', userId);
+  }
+
+  // Function that AI agents can call
+  @aiFunction('Gets order status', [
+    { name: 'orderId', type: 'string', required: true }
+  ])
+  async getOrderStatus({ orderId }: { orderId: string }): Promise<string> {
+    const order = await this.squid.collection('orders').doc({ id: orderId }).snapshot();
+    return order?.status || 'not found';
+  }
+}
+```
+
+**Key points:**
+- Backend code has **full permissions** (API key access)
+- Defines **what clients can and cannot do** through security decorators
+- Contains **business logic** that shouldn't be exposed to clients
+- Automatically deployed and scaled by Squid
+
+### 3. Squid Console (Web UI)
+
+**What it is:** A web-based management interface at https://console.getsquid.ai/ for setting up and managing your Squid applications.
+
+**What you can do in the Console:**
+- **Organizations & Applications:**
+  - Create organizations (teams/workspaces)
+  - Create applications (projects)
+  - Manage API keys and secrets
+  - View application logs and metrics
+
+- **AI Studio:**
+  - Create and configure AI agents visually
+  - Set up agent instructions, models, and guardrails
+  - Test agents in real-time
+  - Connect agents to functions and knowledge bases
+
+- **Knowledge Bases:**
+  - Create knowledge bases for RAG (Retrieval Augmented Generation)
+  - Upload documents and manage contexts
+  - Configure embedding models
+
+- **Integrations:**
+  - Connect databases (PostgreSQL, MySQL, MongoDB, etc.)
+  - Connect SaaS services (Stripe, Slack, etc.)
+  - Configure OAuth integrations
+  - Set up storage providers (AWS S3, etc.)
+  - Configure message queues (Kafka, etc.)
+
+- **Monitoring & Debugging:**
+  - View real-time logs
+  - Monitor API usage
+  - Debug agent conversations
+  - Track performance metrics
+
+**Console vs SDK:**
+- **Console is great for:** Initial setup, visual agent configuration, quick testing, monitoring
+- **SDK is more powerful for:** Programmatic control, CI/CD pipelines, dynamic configuration, complex automation
+
+**Example: Everything in Console can be done via SDK (except creating orgs/apps):**
+
+```typescript
+// Console: Click to create an agent with AI Studio
+// SDK equivalent:
+const agent = squid.ai().agent('my-agent');
+await agent.upsert({
+  description: 'Customer support agent',
+  options: {
+    model: 'gpt-4o',
+    instructions: 'You are a helpful support agent...'
+  }
+});
+
+// Console: Upload document to knowledge base
+// SDK equivalent:
+const kb = squid.ai().knowledgeBase('docs');
+await kb.upsertContext({
+  contextId: 'doc-1',
+  text: 'Product documentation...'
+}, pdfFile);
+
+// Console: Configure database integration
+// SDK equivalent:
+const integrations = squid.admin().integrations();
+await integrations.upsertIntegration({
+  integrationId: 'my-db',
+  type: 'postgres',
+  connectionString: 'postgresql://...'
+});
+```
+
+**Key point:** The Console provides a visual interface for management, but everything (except org/app creation) can be automated through the SDK for more flexibility and control.
+
+### How They Work Together
+
+```
+┌─────────────────────┐
+│   CLIENT (Web/     │
+│   Mobile/Server)    │
+│                     │
+│  - Squid SDK init   │
+│  - User auth        │
+│  - Limited access   │
+└──────────┬──────────┘
+           │
+           │ HTTP/WebSocket
+           │
+           ▼
+┌─────────────────────┐
+│  SQUID BACKEND      │
+│  (Your Code)        │
+│                     │
+│  - SquidService     │
+│  - Decorators       │
+│  - Full permissions │
+│  - Business logic   │
+│  - Security rules   │
+└──────────┬──────────┘
+           │
+           │ Deployed via CLI
+           │ or managed via
+           ▼
+┌─────────────────────┐
+│  SQUID CONSOLE      │
+│  (Web UI)           │
+│                     │
+│  - Manage apps      │
+│  - AI Studio        │
+│  - Integrations     │
+│  - Monitoring       │
+└─────────────────────┘
+```
+
+**Development workflow:**
+1. Create application in **Squid Console**
+2. Develop backend services in **Squid Backend** (local development with `squid start`)
+3. Deploy backend to Squid infrastructure (`squid deploy`)
+4. Build **Client** applications that use the Squid Client SDK
+5. Use **Console** for monitoring and management, or use **SDK** for programmatic control
+
 ## CLI Commands
 
 ### Installation
@@ -24,6 +253,7 @@ npm install -g @squidcloud/cli
 
 ### `squid init <project-name>`
 Creates new backend project with `.env` and example service.
+The backend project has access to an already initialized client SDK with API key (full permissions)
 
 ```bash
 squid init backend --appId YOUR_APP_ID --apiKey YOUR_API_KEY --environmentId dev --squidDeveloperId YOUR_DEV_ID --region us-east-1.aws
@@ -66,7 +296,7 @@ The Squid Client SDK can be instantiated in various environments:
 - **Mobile applications** (React Native, etc.)
 - **Desktop applications** (Electron, etc.)
 
-**Important:** When writing backend code that runs on Squid's infrastructure, the Squid client is **already initialized and available** for you (see Backend SDK section). You don't need to manually create a new instance.
+**Important:** When writing backend code that runs on Squid's infrastructure, the Squid client is **already initialized and available with API key and full permissions** for you (see Backend SDK section). You don't need to manually create a new instance.
 
 ### Initialization
 
@@ -286,6 +516,13 @@ userDoc.snapshots().subscribe(data => {
 // Get cached data (no server fetch)
 const cached = userDoc.peek();
 
+// Check if document has data populated
+if (userDoc.hasData) {
+  console.log('Document is loaded');
+  // Access data directly (with defensive copy)
+  console.log(userDoc.data);
+}
+
 // Bulk operations
 await users.insertMany([
   { id: 'user-1', data: { name: 'Alice' } },
@@ -368,11 +605,16 @@ users.query()
     snapshot.data.forEach(doc => console.log(doc.data));
   });
 
-// Pattern matching
+// Pattern matching (CASE-INSENSITIVE by default)
 const results = await users.query()
   .like('email', '%.com') // case-insensitive by default
   .snapshot();
 
+// Case-sensitive pattern matching
+const caseSensitive = await users.query()
+  .like('name', 'John%', true) // third parameter: caseSensitive = true
+  .snapshot();
+
 // Array operators
 const tagged = await posts.query()
   .in('category', ['tech', 'news'])
@@ -799,6 +1041,26 @@ await myAgent.delete();
 // List all agents
 const agents = await squid.ai().listAgents();
 agents.forEach(agent => console.log(`${agent.id}: ${agent.description}`));
+
+// Manage agent API keys
+const apiKey = await myAgent.regenerateApiKey();
+console.log('New API key:', apiKey);
+
+const existingKey = await myAgent.getApiKey();
+console.log('Current API key:', existingKey);
+
+// Update agent options at specific path
+await myAgent.setAgentOptionInPath('temperature', 0.9);
+await myAgent.setAgentOptionInPath('options.maxTokens', 2000);
+
+// Update connected agents
+await myAgent.updateConnectedAgents([
+  { agentId: 'helper-agent', description: 'Helps with tasks' }
+]);
+
+// Update or delete custom guardrails
+await myAgent.updateCustomGuardrails('Never reveal sensitive information');
+await myAgent.deleteCustomGuardrail();
 ```
 
 **Agent Lifecycle:**
@@ -988,7 +1250,8 @@ const chatObs = agent.chat('What is your return policy?', {
   executionPlanOptions: {
     enabled: true, // Agent plans which resources to use
     model: 'gpt-4o',
-    reasoningEffort: 'high'
+    reasoningEffort: 'high',
+    allowClarificationQuestions: false // Allow agent to ask follow-up questions (default: false)
   },
   agentContext: { userId: '123', role: 'admin' }, // Global context passed to all functions
   includeMetadata: false // Include context metadata in response
@@ -1002,9 +1265,13 @@ chatObs.subscribe(text => {
 const response = await agent.ask('Question?', { /* same options */ });
 
 // Ask with annotations (includes file references, citations)
-const result = await agent.askWithAnnotations('Question?');
+const result = await agent.askWithAnnotations('Question?', { /* same options as ask */ });
 console.log(result.responseString);
-console.log(result.annotations);
+console.log(result.annotations); // File references, sources, etc.
+
+// Ask asynchronously (doesn't wait for response, uses job system)
+await agent.askAsync('Long running task', 'job-id-123', { /* same options */ });
+// Check job status later with squid.job().getJob('job-id-123')
 
 // Voice responses
 const voiceResult = await agent.askWithVoiceResponse('Hello', {
@@ -1018,6 +1285,19 @@ const transcribeResult = await agent.transcribeAndChat(audioFile);
 console.log(transcribeResult.transcribedPrompt);
 transcribeResult.responseStream.subscribe(text => console.log(text));
 
+// Transcribe audio and ask (non-streaming)
+const askResult = await agent.transcribeAndAsk(audioFile, { /* ask options */ });
+console.log(askResult.transcribedPrompt);
+console.log(askResult.response);
+
+// Transcribe audio and get voice response
+const voiceResponse = await agent.transcribeAndAskWithVoiceResponse(audioFile, {
+  voiceOptions: { modelName: 'tts-1', voice: 'alloy' }
+});
+console.log(voiceResponse.transcribedPrompt);
+console.log(voiceResponse.responseString);
+console.log(voiceResponse.voiceResponseFile);
+
 // Get chat history
 const history = await agent.getChatHistory('memory-id-123');
 
@@ -1068,6 +1348,22 @@ export class MyService extends SquidService {
 ```typescript
 const kb = squid.ai().knowledgeBase('product-docs');
 
+// Get knowledge base details
+const kbDetails = await kb.getKnowledgeBase();
+console.log(kbDetails);
+
+// Create or update knowledge base
+await kb.upsertKnowledgeBase({
+  description: 'Product documentation knowledge base',
+  // ...other options
+});
+
+// Delete knowledge base
+await kb.delete();
+
+// List all knowledge bases
+const allKBs = await squid.ai().listKnowledgeBases();
+
 // Upsert context (with or without file)
 await kb.upsertContext({
   contextId: 'doc-123',
@@ -1118,6 +1414,25 @@ await kb.deleteContexts(['doc-1', 'doc-2']);
 const allKBs = await squid.ai().listKnowledgeBases();
 ```
 
+### AI - Files
+
+Manage files stored with AI providers (OpenAI, etc.) for use with agents.
+
+```typescript
+const aiFiles = squid.ai().files('openai'); // provider: 'openai' | 'anthropic' | etc.
+
+// Upload file to AI provider
+const fileId = await aiFiles.uploadFile({
+  file: myFile, // Browser File object
+  purpose: 'assistants' // Purpose for the file
+});
+console.log('Uploaded file ID:', fileId);
+
+// Delete file from AI provider
+const deleted = await aiFiles.deleteFile(fileId);
+console.log('File deleted:', deleted);
+```
+
 ### AI - Image & Audio
 
 ```typescript
@@ -1182,6 +1497,84 @@ const apiResult = await squid.ai().executeAiApiCall(
 );
 ```
 
+### AI - Document Extraction & PDF Creation
+
+Extract structured data from documents and create PDFs programmatically.
+
+```typescript
+const extraction = squid.extraction();
+
+// Extract data from document file
+const extractedData = await extraction.extractDataFromDocumentFile(
+  myPdfFile, // File object
+  {
+    schema: {
+      fields: [
+        { name: 'invoiceNumber', type: 'string', description: 'Invoice number' },
+        { name: 'total', type: 'number', description: 'Total amount' },
+        { name: 'date', type: 'date', description: 'Invoice date' }
+      ]
+    }
+  }
+);
+console.log(extractedData);
+
+// Extract data from document URL
+const urlData = await extraction.extractDataFromDocumentUrl(
+  'https://example.com/document.pdf',
+  {
+    schema: {
+      fields: [
+        { name: 'title', type: 'string' },
+        { name: 'author', type: 'string' }
+      ]
+    }
+  }
+);
+
+// Create PDF from HTML or markdown
+const pdfResponse = await extraction.createPdf({
+  content: '<h1>Hello</h1><p>This is a PDF</p>',
+  contentType: 'html', // or 'markdown'
+  options: {
+    pageSize: 'A4',
+    margin: { top: '1cm', bottom: '1cm', left: '1cm', right: '1cm' }
+  }
+});
+console.log('PDF created:', pdfResponse.url);
+```
+
+**Use cases:**
+- Invoice/receipt processing
+- Form data extraction
+- PDF report generation
+- Document digitization
+- Automated data entry
+
+### AI - Application Settings
+
+Manage AI provider settings and API keys for your application.
+
+```typescript
+const aiClient = squid.ai();
+
+// Get application AI settings
+const settings = await aiClient.getApplicationAiSettings();
+console.log(settings);
+
+// Set application AI settings
+await aiClient.setApplicationAiSettings({
+  defaultModel: 'gpt-4o',
+  // ... other settings
+});
+
+// Set AI provider API key secret
+await aiClient.setAiProviderApiKeySecret(
+  'openai', // providerType: 'openai' | 'anthropic' | 'google' | etc.
+  'OPENAI_API_KEY' // secret key name from secrets manager
+);
+```
+
 ### Storage
 
 ```typescript
@@ -1208,6 +1601,34 @@ await storage.deleteFile('/documents/report.pdf');
 await storage.deleteFiles(['/docs/file1.pdf', '/docs/file2.pdf']);
 ```
 
+### External OAuth Integration
+
+Manage OAuth tokens for external integrations. Squid automatically handles token refresh when tokens expire.
+
+```typescript
+const externalAuth = squid.externalAuth('google-oauth-integration');
+
+// Save authorization code (exchange for access token)
+const tokenResponse = await externalAuth.saveAuthCode(
+  'authorization-code-from-oauth-flow',
+  'user-identifier' // Unique identifier for this user
+);
+console.log('Access token:', tokenResponse.accessToken);
+console.log('Refresh token:', tokenResponse.refreshToken);
+console.log('Expires at:', tokenResponse.expiresAt);
+
+// Get access token (auto-refreshes if expired)
+const token = await externalAuth.getAccessToken('user-identifier');
+console.log('Current access token:', token.accessToken);
+```
+
+**Use cases:**
+- Google Drive/Calendar integration
+- GitHub OAuth
+- Slack OAuth
+- Any external service requiring OAuth 2.0
+- Squid handles token refresh automatically
+
 ### Queues
 
 ```typescript
@@ -1240,13 +1661,22 @@ try {
   lock.release(); // Note: release() is synchronous
 }
 
-// Check if released
-console.log(lock.isReleased()); // true after release
+// Acquire with auto-release timeout (maxHoldTimeMillis)
+const lockWithTimeout = await squid.acquireLock('my-mutex', {
+  maxHoldTimeMillis: 30000 // Auto-release after 30 seconds
+});
+
+// Access lock properties
+console.log(lock.resourceId); // The mutex name: 'payment-processing'
+console.log(lock.lockId); // Unique ID for this lock instance
+console.log(lock.isReleased()); // Check if released: true/false
 
 // Observe release (RxJS Observable)
 const sub = lock.observeRelease().subscribe(() => {
   console.log('Lock was released');
 });
+// Don't forget to unsubscribe when done
+sub.unsubscribe();
 
 // Automatic release with withLock (recommended)
 const result = await squid.withLock('payment-processing', async (lock) => {
@@ -1261,6 +1691,7 @@ const result = await squid.withLock('payment-processing', async (lock) => {
 **Important notes:**
 - Lock is automatically released if WebSocket connection is lost
 - If lock is already held by another client, `acquireLock()` will reject
+- `maxHoldTimeMillis` option automatically releases lock after specified duration
 - Use `@secureDistributedLock(mutexName?)` decorator to secure lock access
 - Without API key, you must define security rules for locks
 
@@ -1269,19 +1700,32 @@ const result = await squid.withLock('payment-processing', async (lock) => {
 ```typescript
 const api = squid.api();
 
-// HTTP methods
-const customer = await api.get<Customer>('stripe-api', 'get-customer', {
+// HTTP methods - All return HttpResponse<T> with status, headers, and body
+const customerResponse = await api.get<Customer>('stripe-api', 'get-customer', {
   pathParams: { customerId: 'cus_123' },
   queryParams: { expand: 'subscriptions' }
 });
+// Access response details
+console.log(customerResponse.status); // HTTP status code
+console.log(customerResponse.headers); // Response headers
+console.log(customerResponse.body); // Parsed response body
 
-const charge = await api.post<Charge, ChargeRequest>(
+const chargeResponse = await api.post<Charge, ChargeRequest>(
   'stripe-api',
   'create-charge',
   { amount: 1000, currency: 'usd' },
   { headers: { 'Idempotency-Key': 'unique' } }
 );
 
+// Generic request method (for custom HTTP methods or complex requests)
+const response = await api.request<ResponseType, RequestType>(
+  'integration-id',
+  'endpoint-id',
+  requestBody,
+  { headers: {}, queryParams: {} },
+  'POST' // or 'GET', 'PUT', 'PATCH', 'DELETE'
+);
+
 // Other methods: put, patch, delete
 await api.put(integrationId, endpointId, body, options);
 await api.patch(integrationId, endpointId, body, options);
@@ -1354,6 +1798,35 @@ const metrics = await obs.queryMetrics({
 await obs.flush();
 ```
 
+### Custom Notifications
+
+Send custom messages between clients for real-time coordination.
+
+```typescript
+const notifications = squid.getNotificationClient();
+
+// Observe incoming notifications
+const subscription = notifications.observeNotifications().subscribe(payload => {
+  console.log('Received notification:', payload);
+  // payload can be any serializable data
+});
+
+// Publish notification to specific clients - can be done only if Squid was initialized with API key.
+await notifications.publishNotification(
+  { type: 'update', message: 'Data changed' }, // payload
+  ['client-id-1', 'client-id-2'] // target client IDs
+);
+
+// Unsubscribe when done
+subscription.unsubscribe();
+```
+
+**Use cases:**
+- Real-time coordination between users
+- Custom event notifications
+- Client-to-client messaging
+- Broadcast updates to specific users
+
 ### Jobs
 
 Jobs allow you to track the status of long-running asynchronous operations. Each job has a unique ID that can be used to query its status or wait for completion.
@@ -1406,6 +1879,24 @@ await integrations.upsertIntegration({
 // Delete
 await integrations.delete('old-integration');
 await integrations.deleteMany(['int-1', 'int-2']);
+
+// Get integration schema
+const schema = await integrations.getIntegrationSchema<MySchemaType>('postgres-db');
+console.log(schema);
+
+// Set integration schema
+await integrations.setIntegrationSchema('postgres-db', {
+  collections: [
+    {
+      name: 'users',
+      fields: [
+        { name: 'id', type: 'string', primaryKey: true },
+        { name: 'email', type: 'string' },
+        { name: 'name', type: 'string' }
+      ]
+    }
+  ]
+});
 ```
 
 ### Admin - Secrets

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squidcloud/cli",
-  "version": "1.0.416",
+  "version": "1.0.418",
   "description": "The Squid CLI",
   "main": "dist/index.js",
   "scripts": {
@@ -28,7 +28,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@squidcloud/local-backend": "^1.0.416",
+    "@squidcloud/local-backend": "^1.0.418",
     "adm-zip": "^0.5.16",
     "copy-webpack-plugin": "^12.0.2",
     "decompress": "^4.2.1",