@hilbras/angular 0.17.0

package/dist/angular-shim.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @hilbras/angular — Minimal Angular-compatible signal types
+ *
+ * These are minimal type definitions that match Angular's signal API.
+ * When used with real Angular, the actual @angular/core provides these.
+ */
+export interface WritableSignal<T> {
+    (): T;
+    set(value: T): void;
+    update(fn: (value: T) => T): void;
+    asReadonly(): Signal<T>;
+}
+export interface Signal<T> {
+    (): T;
+}
+export declare function signal<T>(initialValue: T): WritableSignal<T>;
+export declare function computed<T>(fn: () => T): Signal<T>;
+export declare function Injectable(options?: any): ClassDecorator;

package/dist/angular-shim.js

@@ -0,0 +1,21 @@
+/**
+ * @hilbras/angular — Minimal Angular-compatible signal types
+ *
+ * These are minimal type definitions that match Angular's signal API.
+ * When used with real Angular, the actual @angular/core provides these.
+ */
+export function signal(initialValue) {
+    let value = initialValue;
+    const fn = () => value;
+    fn.set = (v) => { value = v; };
+    fn.update = (upd) => { value = upd(value); };
+    fn.asReadonly = () => fn;
+    return fn;
+}
+export function computed(fn) {
+    return fn;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function Injectable(options) {
+    return () => { };
+}

package/dist/chat.service.d.ts

@@ -0,0 +1,52 @@
+/**
+ * @hilbras/angular — Chat Service
+ *
+ * Angular service for streaming chat conversations with an LLM backend.
+ * Uses Angular signals for reactive state management.
+ *
+ * Usage:
+ *   @Component({ ... })
+ *   export class ChatComponent {
+ *     chat = inject(HilbrasChatService);
+ *     messages = this.chat.messages;
+ *     isLoading = this.chat.isLoading;
+ *
+ *     send() {
+ *       this.chat.submit({ api: '/api/chat', body: { model: 'gpt-4o' } });
+ *     }
+ *   }
+ */
+export interface UIMessage {
+    id: string;
+    role: "user" | "assistant" | "system" | "tool";
+    content: string;
+    createdAt?: number;
+    provider?: string;
+    model?: string;
+}
+export interface ChatOptions {
+    api: string;
+    initialMessages?: UIMessage[];
+    provider?: string;
+    model?: string;
+    onFinish?: (messages: UIMessage[]) => void;
+    onError?: (error: Error) => void;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+export declare class HilbrasChatService {
+    private _messages;
+    private _input;
+    private _isLoading;
+    private _error;
+    private _abortController;
+    readonly messages: import("./angular-shim.js").Signal<UIMessage[]>;
+    readonly input: import("./angular-shim.js").Signal<string>;
+    readonly isLoading: import("./angular-shim.js").Signal<boolean>;
+    readonly error: import("./angular-shim.js").Signal<Error | null>;
+    readonly hasMessages: import("./angular-shim.js").Signal<boolean>;
+    setInput(value: string): void;
+    stop(): void;
+    clear(): void;
+    submit(options: ChatOptions): Promise<void>;
+}

package/dist/chat.service.js

@@ -0,0 +1,153 @@
+/**
+ * @hilbras/angular — Chat Service
+ *
+ * Angular service for streaming chat conversations with an LLM backend.
+ * Uses Angular signals for reactive state management.
+ *
+ * Usage:
+ *   @Component({ ... })
+ *   export class ChatComponent {
+ *     chat = inject(HilbrasChatService);
+ *     messages = this.chat.messages;
+ *     isLoading = this.chat.isLoading;
+ *
+ *     send() {
+ *       this.chat.submit({ api: '/api/chat', body: { model: 'gpt-4o' } });
+ *     }
+ *   }
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable, signal, computed } from "./angular-shim.js";
+let _idCounter = 0;
+function generateId() {
+    return `msg_${Date.now()}_${_idCounter++}`;
+}
+let HilbrasChatService = class HilbrasChatService {
+    _messages = signal([]);
+    _input = signal("");
+    _isLoading = signal(false);
+    _error = signal(null);
+    _abortController = null;
+    messages = this._messages.asReadonly();
+    input = this._input.asReadonly();
+    isLoading = this._isLoading.asReadonly();
+    error = this._error.asReadonly();
+    hasMessages = computed(() => this._messages().length > 0);
+    setInput(value) {
+        this._input.set(value);
+    }
+    stop() {
+        this._abortController?.abort();
+        this._abortController = null;
+        this._isLoading.set(false);
+    }
+    clear() {
+        this._messages.set([]);
+        this._input.set("");
+        this._error.set(null);
+        this.stop();
+    }
+    async submit(options) {
+        const trimmed = this._input().trim();
+        if (!trimmed || this._isLoading())
+            return;
+        const userMessage = {
+            id: generateId(),
+            role: "user",
+            content: trimmed,
+            createdAt: Date.now(),
+        };
+        const assistantMessage = {
+            id: generateId(),
+            role: "assistant",
+            content: "",
+            createdAt: Date.now(),
+            provider: options.provider,
+            model: options.model,
+        };
+        this._messages.update((msgs) => [...msgs, userMessage, assistantMessage]);
+        this._input.set("");
+        this._isLoading.set(true);
+        this._error.set(null);
+        const controller = new AbortController();
+        this._abortController = controller;
+        try {
+            const res = await fetch(options.api, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...options.headers },
+                body: JSON.stringify({
+                    messages: this._messages().slice(0, -1).map((m) => ({
+                        role: m.role,
+                        content: m.content,
+                    })),
+                    stream: true,
+                    ...options.body,
+                }),
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            if (!res.body)
+                throw new Error("Response body is null");
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const parts = buffer.split("\n\n");
+                buffer = parts.pop() ?? "";
+                for (const part of parts) {
+                    const lines = part.split("\n");
+                    let rawData = "";
+                    for (const line of lines) {
+                        if (line.startsWith("data: "))
+                            rawData = line.slice(6).trim();
+                    }
+                    if (!rawData || rawData === "[DONE]")
+                        continue;
+                    let data;
+                    try {
+                        data = JSON.parse(rawData);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (data.type === "text" && typeof data.text === "string") {
+                        this._messages.update((msgs) => {
+                            const updated = [...msgs];
+                            const last = updated[updated.length - 1];
+                            if (last)
+                                updated[updated.length - 1] = { ...last, content: last.content + data.text };
+                            return updated;
+                        });
+                    }
+                }
+            }
+            const finalMessages = this._messages();
+            options.onFinish?.(finalMessages);
+        }
+        catch (err) {
+            if (err.name === "AbortError")
+                return;
+            const error = err instanceof Error ? err : new Error(String(err));
+            this._error.set(error);
+            options.onError?.(error);
+        }
+        finally {
+            this._abortController = null;
+            this._isLoading.set(false);
+        }
+    }
+};
+HilbrasChatService = __decorate([
+    Injectable({ providedIn: "root" })
+], HilbrasChatService);
+export { HilbrasChatService };

package/dist/completion.service.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @hilbras/angular — Completion Service
+ *
+ * Angular service for streaming text completions from an LLM backend.
+ * Uses Angular signals for reactive state management.
+ *
+ * Usage:
+ *   @Component({ ... })
+ *   export class CompletionComponent {
+ *     completion = inject(HilbrasCompletionService);
+ *     text = this.completion.text;
+ *   }
+ */
+export interface CompletionOptions {
+    api: string;
+    prompt?: string;
+    onFinish?: (text: string) => void;
+    onError?: (error: Error) => void;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+export declare class HilbrasCompletionService {
+    private _text;
+    private _isLoading;
+    private _error;
+    private _abortController;
+    readonly text: import("./angular-shim.js").Signal<string>;
+    readonly isLoading: import("./angular-shim.js").Signal<boolean>;
+    readonly error: import("./angular-shim.js").Signal<Error | null>;
+    stop(): void;
+    clear(): void;
+    submit(options: CompletionOptions): Promise<void>;
+}

package/dist/completion.service.js

@@ -0,0 +1,113 @@
+/**
+ * @hilbras/angular — Completion Service
+ *
+ * Angular service for streaming text completions from an LLM backend.
+ * Uses Angular signals for reactive state management.
+ *
+ * Usage:
+ *   @Component({ ... })
+ *   export class CompletionComponent {
+ *     completion = inject(HilbrasCompletionService);
+ *     text = this.completion.text;
+ *   }
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable, signal } from "./angular-shim.js";
+let HilbrasCompletionService = class HilbrasCompletionService {
+    _text = signal("");
+    _isLoading = signal(false);
+    _error = signal(null);
+    _abortController = null;
+    text = this._text.asReadonly();
+    isLoading = this._isLoading.asReadonly();
+    error = this._error.asReadonly();
+    stop() {
+        this._abortController?.abort();
+        this._abortController = null;
+        this._isLoading.set(false);
+    }
+    clear() {
+        this._text.set("");
+        this._error.set(null);
+        this.stop();
+    }
+    async submit(options) {
+        if (this._isLoading())
+            return;
+        this._text.set("");
+        this._isLoading.set(true);
+        this._error.set(null);
+        const controller = new AbortController();
+        this._abortController = controller;
+        try {
+            const res = await fetch(options.api, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...options.headers },
+                body: JSON.stringify({
+                    prompt: options.prompt ?? "",
+                    stream: true,
+                    ...options.body,
+                }),
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            if (!res.body)
+                throw new Error("Response body is null");
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let fullText = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const parts = buffer.split("\n\n");
+                buffer = parts.pop() ?? "";
+                for (const part of parts) {
+                    const lines = part.split("\n");
+                    let rawData = "";
+                    for (const line of lines) {
+                        if (line.startsWith("data: "))
+                            rawData = line.slice(6).trim();
+                    }
+                    if (!rawData || rawData === "[DONE]")
+                        continue;
+                    let data;
+                    try {
+                        data = JSON.parse(rawData);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (data.type === "text" && typeof data.text === "string") {
+                        fullText += data.text;
+                        this._text.set(fullText);
+                    }
+                }
+            }
+            options.onFinish?.(fullText);
+        }
+        catch (err) {
+            if (err.name === "AbortError")
+                return;
+            const error = err instanceof Error ? err : new Error(String(err));
+            this._error.set(error);
+            options.onError?.(error);
+        }
+        finally {
+            this._abortController = null;
+            this._isLoading.set(false);
+        }
+    }
+};
+HilbrasCompletionService = __decorate([
+    Injectable({ providedIn: "root" })
+], HilbrasCompletionService);
+export { HilbrasCompletionService };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @hilbras/angular — Public API
+ *
+ * Angular services for building streaming LLM UIs with @hilbras/sdk.
+ */
+export { HilbrasChatService } from "./chat.service.js";
+export type { ChatOptions } from "./chat.service.js";
+export { HilbrasCompletionService } from "./completion.service.js";
+export type { CompletionOptions } from "./completion.service.js";
+export { HilbrasObjectService } from "./object.service.js";
+export type { ObjectOptions } from "./object.service.js";

package/dist/index.js

@@ -0,0 +1,8 @@
+/**
+ * @hilbras/angular — Public API
+ *
+ * Angular services for building streaming LLM UIs with @hilbras/sdk.
+ */
+export { HilbrasChatService } from "./chat.service.js";
+export { HilbrasCompletionService } from "./completion.service.js";
+export { HilbrasObjectService } from "./object.service.js";

package/dist/object.service.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @hilbras/angular — Object Service
+ *
+ * Angular service for streaming structured JSON output from an LLM backend.
+ * Uses Angular signals for reactive state management.
+ *
+ * Usage:
+ *   @Component({ ... })
+ *   export class ObjectComponent {
+ *     obj = inject(HilbrasObjectService);
+ *     partial = this.obj.object;
+ *   }
+ */
+export interface ObjectOptions<T> {
+    api: string;
+    schemaName: string;
+    onFinish?: (object: T) => void;
+    onError?: (error: Error) => void;
+    headers?: Record<string, string>;
+    body?: Record<string, unknown>;
+}
+export declare class HilbrasObjectService {
+    private _object;
+    private _isLoading;
+    private _error;
+    private _abortController;
+    readonly object: import("./angular-shim.js").Signal<Partial<unknown> | null>;
+    readonly isLoading: import("./angular-shim.js").Signal<boolean>;
+    readonly error: import("./angular-shim.js").Signal<Error | null>;
+    stop(): void;
+    clear(): void;
+    submit<T>(options: ObjectOptions<T>): Promise<void>;
+}

package/dist/object.service.js

@@ -0,0 +1,118 @@
+/**
+ * @hilbras/angular — Object Service
+ *
+ * Angular service for streaming structured JSON output from an LLM backend.
+ * Uses Angular signals for reactive state management.
+ *
+ * Usage:
+ *   @Component({ ... })
+ *   export class ObjectComponent {
+ *     obj = inject(HilbrasObjectService);
+ *     partial = this.obj.object;
+ *   }
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Injectable, signal } from "./angular-shim.js";
+let HilbrasObjectService = class HilbrasObjectService {
+    _object = signal(null);
+    _isLoading = signal(false);
+    _error = signal(null);
+    _abortController = null;
+    object = this._object.asReadonly();
+    isLoading = this._isLoading.asReadonly();
+    error = this._error.asReadonly();
+    stop() {
+        this._abortController?.abort();
+        this._abortController = null;
+        this._isLoading.set(false);
+    }
+    clear() {
+        this._object.set(null);
+        this._error.set(null);
+        this.stop();
+    }
+    async submit(options) {
+        if (this._isLoading())
+            return;
+        this._object.set(null);
+        this._isLoading.set(true);
+        this._error.set(null);
+        const controller = new AbortController();
+        this._abortController = controller;
+        try {
+            const res = await fetch(options.api, {
+                method: "POST",
+                headers: { "Content-Type": "application/json", ...options.headers },
+                body: JSON.stringify({
+                    schema: options.schemaName,
+                    stream: true,
+                    ...options.body,
+                }),
+                signal: controller.signal,
+            });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}: ${res.statusText}`);
+            if (!res.body)
+                throw new Error("Response body is null");
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            let partialArgs = "";
+            let result = {};
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const parts = buffer.split("\n\n");
+                buffer = parts.pop() ?? "";
+                for (const part of parts) {
+                    const lines = part.split("\n");
+                    let rawData = "";
+                    for (const line of lines) {
+                        if (line.startsWith("data: "))
+                            rawData = line.slice(6).trim();
+                    }
+                    if (!rawData || rawData === "[DONE]")
+                        continue;
+                    let data;
+                    try {
+                        data = JSON.parse(rawData);
+                    }
+                    catch {
+                        continue;
+                    }
+                    if (data.type === "tool_call_delta" && data.args) {
+                        partialArgs += data.args;
+                        try {
+                            result = JSON.parse(partialArgs);
+                            this._object.set({ ...result });
+                        }
+                        catch { /* partial JSON */ }
+                    }
+                }
+            }
+            options.onFinish?.(result);
+        }
+        catch (err) {
+            if (err.name === "AbortError")
+                return;
+            const error = err instanceof Error ? err : new Error(String(err));
+            this._error.set(error);
+            options.onError?.(error);
+        }
+        finally {
+            this._abortController = null;
+            this._isLoading.set(false);
+        }
+    }
+};
+HilbrasObjectService = __decorate([
+    Injectable({ providedIn: "root" })
+], HilbrasObjectService);
+export { HilbrasObjectService };

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@hilbras/angular",
+  "version": "0.17.0",
+  "description": "Angular services for @hilbras/sdk — chat, completion, object streaming",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=19",
+    "@angular/common": ">=19",
+    "@hilbras/sdk": ">=0.16.0",
+    "rxjs": ">=7"
+  },
+  "devDependencies": {
+    "@angular/core": "^19.0.0",
+    "@angular/common": "^19.0.0",
+    "rxjs": "^7.8.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Hilbras/Hilbras-ai-sdk.git",
+    "directory": "packages/angular"
+  }
+}