@agentick/angular 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,131 @@
+/**
+ * @agentick/angular - Modern Angular bindings for Agentick
+ *
+ * Uses Angular signals for reactive state with RxJS interop for compatibility.
+ *
+ * @example Standalone setup
+ * ```typescript
+ * import { TENTICKLE_CONFIG } from '@agentick/angular';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     { provide: TENTICKLE_CONFIG, useValue: { baseUrl: 'https://api.example.com' } },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Component with signals (recommended)
+ * ```typescript
+ * import { Component, inject } from '@angular/core';
+ * import { AgentickService } from '@agentick/angular';
+ *
+ * @Component({
+ *   selector: 'app-chat',
+ *   standalone: true,
+ *   template: `
+ *     <div class="response">
+ *       {{ agentick.text() }}
+ *       @if (agentick.isStreaming()) {
+ *         <span class="cursor">|</span>
+ *       }
+ *     </div>
+ *     <input #input />
+ *     <button (click)="send(input.value); input.value = ''">Send</button>
+ *   `,
+ * })
+ * export class ChatComponent {
+ *   agentick = inject(AgentickService);
+ *
+ *   constructor() {
+ *     this.agentick.subscribe("conv-123");
+ *   }
+ *
+ *   async send(message: string) {
+ *     const handle = this.agentick.send(message);
+ *     await handle.result;
+ *   }
+ * }
+ * ```
+ *
+ * @example With RxJS (for legacy or complex reactive flows)
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div>{{ text$ | async }}</div>
+ *   `,
+ * })
+ * export class LegacyComponent {
+ *   agentick = inject(AgentickService);
+ *   text$ = this.agentick.text$;
+ * }
+ * ```
+ *
+ * @example Multiple agents with separate instances
+ * ```typescript
+ * import { provideAgentick, AgentickService } from '@agentick/angular';
+ *
+ * // Each component gets its own service instance
+ * @Component({
+ *   selector: 'app-support-chat',
+ *   standalone: true,
+ *   providers: [provideAgentick({ baseUrl: '/api/support-agent' })],
+ *   template: `<div>{{ agentick.text() }}</div>`,
+ * })
+ * export class SupportChatComponent {
+ *   agentick = inject(AgentickService);
+ * }
+ *
+ * @Component({
+ *   selector: 'app-sales-chat',
+ *   standalone: true,
+ *   providers: [provideAgentick({ baseUrl: '/api/sales-agent' })],
+ *   template: `<div>{{ agentick.text() }}</div>`,
+ * })
+ * export class SalesChatComponent {
+ *   agentick = inject(AgentickService);
+ * }
+ * ```
+ *
+ * ## Signals (Primary API)
+ *
+ * | Signal | Type | Description |
+ * |--------|------|-------------|
+ * | `connectionState()` | `ConnectionState` | Connection state |
+ * | `sessionId()` | `string \| undefined` | Active session ID |
+ * | `streamingText()` | `StreamingTextState` | Text + isStreaming |
+ * | `text()` | `string` | Just the text (computed) |
+ * | `isStreaming()` | `boolean` | Whether streaming (computed) |
+ *
+ * ## RxJS Observables (Compatibility)
+ *
+ * | Observable | Type | Description |
+ * |------------|------|-------------|
+ * | `connectionState$` | `ConnectionState` | Connection state |
+ * | `isConnected$` | `boolean` | Whether connected |
+ * | `streamingText$` | `StreamingTextState` | Text + isStreaming |
+ * | `text$` | `string` | Just the text |
+ * | `isStreaming$` | `boolean` | Whether streaming |
+ * | `events$` | `StreamEvent | SessionStreamEvent` | All stream events |
+ * | `result$` | `Result` | Execution results |
+ *
+ * ## Methods
+ *
+ * | Method | Description |
+ * |--------|-------------|
+ * | `session(sessionId)` | Get cold accessor |
+ * | `subscribe(sessionId)` | Subscribe (hot) |
+ * | `unsubscribe()` | Unsubscribe active session |
+ * | `send(input)` | Send message |
+ * | `abort(reason?)` | Abort execution |
+ * | `close()` | Close active session |
+ * | `channel(name)` | Get channel accessor |
+ * | `channel$(name)` | Get channel as Observable |
+ * | `eventsOfType(...types)` | Filter events by type |
+ * | `clearStreamingText()` | Clear accumulated text |
+ *
+ * @module @agentick/angular
+ */
+export { AgentickService, TENTICKLE_CONFIG, provideAgentick } from "./agentick.service";
+export type { AgentickConfig, TransportConfig, AgentickClient, ConnectionState, StreamEvent, SessionStreamEvent, ClientExecutionHandle, StreamingTextState, ClientTransport, } from "./types";
+export { createClient } from "@agentick/client";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8HG;AAGH,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGxF,YAAY,EACV,cAAc,EACd,eAAe,EACf,cAAc,EACd,eAAe,EACf,WAAW,EACX,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,eAAe,GAChB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -0,0 +1,132 @@
+/**
+ * @agentick/angular - Modern Angular bindings for Agentick
+ *
+ * Uses Angular signals for reactive state with RxJS interop for compatibility.
+ *
+ * @example Standalone setup
+ * ```typescript
+ * import { TENTICKLE_CONFIG } from '@agentick/angular';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     { provide: TENTICKLE_CONFIG, useValue: { baseUrl: 'https://api.example.com' } },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Component with signals (recommended)
+ * ```typescript
+ * import { Component, inject } from '@angular/core';
+ * import { AgentickService } from '@agentick/angular';
+ *
+ * @Component({
+ *   selector: 'app-chat',
+ *   standalone: true,
+ *   template: `
+ *     <div class="response">
+ *       {{ agentick.text() }}
+ *       @if (agentick.isStreaming()) {
+ *         <span class="cursor">|</span>
+ *       }
+ *     </div>
+ *     <input #input />
+ *     <button (click)="send(input.value); input.value = ''">Send</button>
+ *   `,
+ * })
+ * export class ChatComponent {
+ *   agentick = inject(AgentickService);
+ *
+ *   constructor() {
+ *     this.agentick.subscribe("conv-123");
+ *   }
+ *
+ *   async send(message: string) {
+ *     const handle = this.agentick.send(message);
+ *     await handle.result;
+ *   }
+ * }
+ * ```
+ *
+ * @example With RxJS (for legacy or complex reactive flows)
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     <div>{{ text$ | async }}</div>
+ *   `,
+ * })
+ * export class LegacyComponent {
+ *   agentick = inject(AgentickService);
+ *   text$ = this.agentick.text$;
+ * }
+ * ```
+ *
+ * @example Multiple agents with separate instances
+ * ```typescript
+ * import { provideAgentick, AgentickService } from '@agentick/angular';
+ *
+ * // Each component gets its own service instance
+ * @Component({
+ *   selector: 'app-support-chat',
+ *   standalone: true,
+ *   providers: [provideAgentick({ baseUrl: '/api/support-agent' })],
+ *   template: `<div>{{ agentick.text() }}</div>`,
+ * })
+ * export class SupportChatComponent {
+ *   agentick = inject(AgentickService);
+ * }
+ *
+ * @Component({
+ *   selector: 'app-sales-chat',
+ *   standalone: true,
+ *   providers: [provideAgentick({ baseUrl: '/api/sales-agent' })],
+ *   template: `<div>{{ agentick.text() }}</div>`,
+ * })
+ * export class SalesChatComponent {
+ *   agentick = inject(AgentickService);
+ * }
+ * ```
+ *
+ * ## Signals (Primary API)
+ *
+ * | Signal | Type | Description |
+ * |--------|------|-------------|
+ * | `connectionState()` | `ConnectionState` | Connection state |
+ * | `sessionId()` | `string \| undefined` | Active session ID |
+ * | `streamingText()` | `StreamingTextState` | Text + isStreaming |
+ * | `text()` | `string` | Just the text (computed) |
+ * | `isStreaming()` | `boolean` | Whether streaming (computed) |
+ *
+ * ## RxJS Observables (Compatibility)
+ *
+ * | Observable | Type | Description |
+ * |------------|------|-------------|
+ * | `connectionState$` | `ConnectionState` | Connection state |
+ * | `isConnected$` | `boolean` | Whether connected |
+ * | `streamingText$` | `StreamingTextState` | Text + isStreaming |
+ * | `text$` | `string` | Just the text |
+ * | `isStreaming$` | `boolean` | Whether streaming |
+ * | `events$` | `StreamEvent | SessionStreamEvent` | All stream events |
+ * | `result$` | `Result` | Execution results |
+ *
+ * ## Methods
+ *
+ * | Method | Description |
+ * |--------|-------------|
+ * | `session(sessionId)` | Get cold accessor |
+ * | `subscribe(sessionId)` | Subscribe (hot) |
+ * | `unsubscribe()` | Unsubscribe active session |
+ * | `send(input)` | Send message |
+ * | `abort(reason?)` | Abort execution |
+ * | `close()` | Close active session |
+ * | `channel(name)` | Get channel accessor |
+ * | `channel$(name)` | Get channel as Observable |
+ * | `eventsOfType(...types)` | Filter events by type |
+ * | `clearStreamingText()` | Clear accumulated text |
+ *
+ * @module @agentick/angular
+ */
+// Service, token, and provider factory
+export { AgentickService, TENTICKLE_CONFIG, provideAgentick } from "./agentick.service";
+// Re-export createClient for advanced usage
+export { createClient } from "@agentick/client";
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8HG;AAEH,uCAAuC;AACvC,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAexF,4CAA4C;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/tentickle.service.d.ts

@@ -0,0 +1,210 @@
+/**
+ * TentickleService - Modern Angular service for Tentickle.
+ *
+ * Uses Angular signals for reactive state management with RxJS interop.
+ *
+ * @module @tentickle/angular/service
+ */
+import { InjectionToken, type OnDestroy } from "@angular/core";
+import { Observable } from "rxjs";
+import { type TentickleClient, type ConnectionState, type StreamEvent, type StreamingTextState, type SessionStreamEvent, type SessionAccessor, type ClientExecutionHandle } from "@tentickle/client";
+import type { TentickleConfig } from "./types";
+/**
+ * Injection token for Tentickle configuration.
+ */
+export declare const TENTICKLE_CONFIG: InjectionToken<TentickleConfig>;
+/**
+ * Provides TentickleService with configuration at component level.
+ *
+ * Use this to create isolated service instances for different components,
+ * each with their own connection and state.
+ *
+ * @example Multiple agents in one app
+ * ```typescript
+ * // Each component gets its own TentickleService instance
+ *
+ * @Component({
+ *   selector: 'app-support-chat',
+ *   providers: [provideTentickle({ baseUrl: '/api/support-agent' })],
+ *   template: `<div>{{ tentickle.text() }}</div>`,
+ * })
+ * export class SupportChatComponent {
+ *   tentickle = inject(TentickleService);
+ * }
+ *
+ * @Component({
+ *   selector: 'app-sales-chat',
+ *   providers: [provideTentickle({ baseUrl: '/api/sales-agent' })],
+ *   template: `<div>{{ tentickle.text() }}</div>`,
+ * })
+ * export class SalesChatComponent {
+ *   tentickle = inject(TentickleService);
+ * }
+ * ```
+ *
+ * @param config - Configuration for this service instance
+ * @returns Provider array to spread into component's providers
+ */
+export declare function provideTentickle(config: TentickleConfig): (typeof TentickleService | {
+    provide: InjectionToken<TentickleConfig>;
+    useValue: TentickleConfig;
+})[];
+/**
+ * Modern Angular service for Tentickle.
+ *
+ * Uses signals for state, with RxJS observables available for compatibility.
+ *
+ * @example Standalone setup
+ * ```typescript
+ * import { TentickleService, TENTICKLE_CONFIG } from '@tentickle/angular';
+ *
+ * bootstrapApplication(AppComponent, {
+ *   providers: [
+ *     { provide: TENTICKLE_CONFIG, useValue: { baseUrl: 'https://api.example.com' } },
+ *   ],
+ * });
+ * ```
+ *
+ * @example Component with signals
+ * ```typescript
+ * @Component({
+ *   template: `
+ *     @if (tentickle.isConnected()) {
+ *       <div class="response">
+ *         {{ tentickle.text() }}
+ *         @if (tentickle.isStreaming()) {
+ *           <span class="cursor">|</span>
+ *         }
+ *       </div>
+ *       <input #input />
+ *       <button (click)="send(input.value)">Send</button>
+ *     } @else {
+ *       <p>Connecting...</p>
+ *     }
+ *   `,
+ * })
+ * export class ChatComponent {
+ *   tentickle = inject(TentickleService);
+ *
+ *   constructor() {
+ *     this.tentickle.subscribe("conv-123");
+ *   }
+ *
+ *   async send(message: string) {
+ *     const handle = this.tentickle.send(message);
+ *     await handle.result;
+ *   }
+ * }
+ * ```
+ *
+ * @example With RxJS (for compatibility)
+ * ```typescript
+ * @Component({
+ *   template: `{{ text$ | async }}`,
+ * })
+ * export class LegacyComponent {
+ *   tentickle = inject(TentickleService);
+ *   text$ = this.tentickle.text$;
+ * }
+ * ```
+ */
+export declare class TentickleService implements OnDestroy {
+    private readonly client;
+    private readonly destroy$;
+    private currentSession?;
+    /** Current connection state */
+    readonly connectionState: import("@angular/core").WritableSignal<ConnectionState>;
+    /** Current session ID */
+    readonly sessionId: import("@angular/core").WritableSignal<string | undefined>;
+    /** Connection error, if any */
+    readonly error: import("@angular/core").WritableSignal<Error | undefined>;
+    /** Streaming text state from the client */
+    readonly streamingText: import("@angular/core").WritableSignal<StreamingTextState>;
+    /** Whether currently connected */
+    readonly isConnected: import("@angular/core").Signal<boolean>;
+    /** Whether currently connecting */
+    readonly isConnecting: import("@angular/core").Signal<boolean>;
+    /** Current streaming text */
+    readonly text: import("@angular/core").Signal<string>;
+    /** Whether currently streaming */
+    readonly isStreaming: import("@angular/core").Signal<boolean>;
+    /** Observable of connection state (for RxJS users) */
+    readonly connectionState$: Observable<ConnectionState>;
+    /** Observable of whether connected (for RxJS users) */
+    readonly isConnected$: Observable<boolean>;
+    /** Observable of streaming text state (for RxJS users) */
+    readonly streamingText$: Observable<StreamingTextState>;
+    /** Observable of just the text (for RxJS users) */
+    readonly text$: Observable<string>;
+    /** Observable of whether streaming (for RxJS users) */
+    readonly isStreaming$: Observable<boolean>;
+    /** Subject for raw stream events */
+    private readonly eventsSubject;
+    /** Observable of all stream events */
+    readonly events$: Observable<StreamEvent | SessionStreamEvent>;
+    /** Subject for execution results */
+    private readonly resultSubject;
+    /** Observable of execution results */
+    readonly result$: Observable<{
+        response: string;
+        outputs: Record<string, unknown>;
+        usage: {
+            inputTokens: number;
+            outputTokens: number;
+            totalTokens: number;
+        };
+        stopReason?: string;
+    }>;
+    /**
+     * Creates a new TentickleService.
+     *
+     * @param configOrInjected - Config passed directly (for testing) or undefined to use DI
+     */
+    constructor(configOrInjected?: TentickleConfig);
+    private setupSubscriptions;
+    /**
+     * Get a cold session accessor.
+     */
+    session(sessionId: string): SessionAccessor;
+    /**
+     * Subscribe to a session and make it the active session.
+     */
+    subscribe(sessionId: string): SessionAccessor;
+    /**
+     * Unsubscribe from the active session.
+     */
+    unsubscribe(): void;
+    /**
+     * Send a message to the session.
+     */
+    send(input: Parameters<TentickleClient["send"]>[0]): ClientExecutionHandle;
+    /**
+     * Abort the current execution.
+     */
+    abort(reason?: string): Promise<void>;
+    /**
+     * Close the active session on the server.
+     */
+    close(): Promise<void>;
+    /**
+     * Clear the accumulated streaming text.
+     */
+    clearStreamingText(): void;
+    /**
+     * Get a channel accessor for custom pub/sub.
+     */
+    channel(name: string): import("@tentickle/client").ChannelAccessor;
+    /**
+     * Create an Observable from a channel.
+     */
+    channel$(name: string): Observable<{
+        type: string;
+        payload: unknown;
+    }>;
+    /**
+     * Filter events by type.
+     */
+    eventsOfType(...types: StreamEvent["type"][]): Observable<StreamEvent>;
+    ngOnDestroy(): void;
+}
+//# sourceMappingURL=tentickle.service.d.ts.map

package/dist/tentickle.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tentickle.service.d.ts","sourceRoot":"","sources":["../src/tentickle.service.ts"],"names":[],"mappings":"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"}