@j-o-r/hello-dave 0.0.2 → 0.0.4

package/scenarios.bak.1774780058/xai_responses.integration.test.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { Test, assert } from '@j-o-r/sh';
+import { request } from '../lib/API/x.ai/responses.js';
+import Prompt from '../lib/Prompt.js';
+import tools from './testToolset.js';  // Reuse weather mock for recursion
+
+const t = new Test();
+
+// Real API: tools + recursion (default model)
+t.add('request: real with tools (recursion)', async () => {
+  const p = new Prompt();
+  p.add('system', 'You are helpful. Use tools for weather.', true);
+  p.add('user', 'Weather in Amsterdam?');
+  const msg = await request(p, tools);
+  assert.strictEqual(msg.role, 'assistant');
+  assert.ok(msg.content.some(c => c.type === 'text'), 'Final text response');
+  const toolMsg = p.messages.find(m => m.role === 'tool');
+  assert.ok(toolMsg, 'Tool executed');
+});
+
+// Real API: custom options (non-reasoning model)
+t.add('request: real options (model/temp/store)', async () => {
+  const p = new Prompt();
+  p.add('system', 'Answer in JSON.', true);
+  p.add('user', '2+2 as JSON.');
+  const msg = await request(p, null, {
+    model: 'grok-4-fast-non-reasoning',
+    temperature: 0.1,
+    store: true,
+    max_output_tokens: 100
+  });
+  assert.strictEqual(msg.role, 'assistant');
+  assert.ok(msg.content[0].text.includes('4'), 'JSON with 4');
+});
+
+// Real API: reasoning rejected (unsupported on default model)
+t.add('request: reasoning rejected on incompatible model', async () => {
+  const p = new Prompt();
+  p.add('user', 'Why is sky blue?');
+  await assert.rejects(
+    () => request(p, null, { reasoning: { effort: 'high', summary: 'concise' } }),
+    /invalid argument|reasoningEffort/
+  );
+});
+
+// Real API: invalid model rejects (4xx)
+t.add('request: invalid model rejects', async () => {
+  const p = new Prompt();
+  p.add('user', 'Hi');
+  await assert.rejects(
+    () => request(p, null, { model: 'invalid-xyz' }),
+    /Error.*4\\d{2}|Model not found|400/
+  );
+});
+
+const report = await t.run();
+process.exit(report.errors > 0 ? 1 : 0);

package/scenarios.bak.1774780058/xai_responses.test.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+import { Test, assert } from '@j-o-r/sh';
+import { generateRequest, parseResponse, request } from '../lib/API/x.ai/responses.js';
+import Prompt from '../lib/Prompt.js';
+import ToolSet from '../lib/ToolSet.js';
+import tools from './testToolset.js';
+
+const t = new Test();
+
+// Fake response helpers
+const fakeTextRes = () => ({
+  status: 200,
+  response: {
+    id: 'fake-text',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 10, output_tokens: 5 },
+    output: [{ type: 'message', content: [{ type: 'output_text', text: 'Hello!' }] }]
+  }
+});
+
+const fakeReasoningRes = () => ({
+  status: 200,
+  response: {
+    id: 'fake-reason',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 10, output_tokens: 5 },
+    output: [{ type: 'reasoning', summary: [{ type: 'summary_text', text: 'Thought.' }] }]
+  }
+});
+
+const fakeCitationRes = () => ({
+  status: 200,
+  response: {
+    id: 'fake-cit',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 10, output_tokens: 5 },
+    output: [{ type: 'message', content: [{ type: 'output_text', text: 'Text', annotations: [{ type: 'url_citation', url: 'https://ex.com' }] }] }]
+  }
+});
+
+const fakeToolRes = (name = 'get_current_weather', args = '{"location":"Amsterdam"}') => ({
+  status: 200,
+  response: {
+    id: 'fake-tool',
+    model: 'grok-beta',
+    created_at: Math.floor(Date.now() / 1000),
+    usage: { input_tokens: 20, output_tokens: 10 },
+    output: [{ type: 'function_call', name, id: 'fid', call_id: 'fcid', arguments: args, status: 'complete' }]
+  }
+});
+
+t.add('generateRequest: basic', () => {
+  const p = new Prompt();
+  p.add('system', 'Helpful', true);
+  p.add('user', 'Hi');
+  const { url, headers, body } = generateRequest(p);
+  assert.strictEqual(url, 'https://api.x.ai/v1/responses');
+  assert.strictEqual(headers['Content-Type'], 'application/json');
+  assert.ok(headers.Authorization.startsWith('Bearer'));
+  assert.strictEqual(body.model, 'grok-4-fast-reasoning');
+  assert.strictEqual(body.instructions, 'Helpful');
+  assert.strictEqual(body.input.length, 1);
+});
+
+t.add('generateRequest: tools', () => {
+  const p = new Prompt();
+  p.add('user', 'Weather');
+  const { body } = generateRequest(p, tools);
+  assert.ok(body.tools.some(tl => tl.name === 'get_current_weather'));
+  assert.strictEqual(body.parallel_tool_calls, true);
+});
+
+t.add('generateRequest: options', () => {
+  const p = new Prompt();
+  p.add('user', 'Hi');
+  const { body } = generateRequest(p, null, { model: 'grok-4-1-fast-reasoning' });
+  assert.strictEqual(body.model, 'grok-4-1-fast-reasoning');
+});
+
+t.add('generateRequest: throws bad last role', () => {
+  const p = new Prompt();
+  p.add('system', '', true);
+  p.add('assistant', 'bad');
+  assert.throws(() => generateRequest(p));
+});
+
+t.add('parseResponse: text', async () => {
+  const p = new Prompt();
+  p.add('user', 'Hi');
+  await parseResponse(100, p, fakeTextRes());
+  const msg = p.getLastMessage();
+  assert.strictEqual(msg.role, 'assistant');
+  assert.strictEqual(msg.content[0].text, 'Hello!');
+});
+
+t.add('parseResponse: reasoning', async () => {
+  const p = new Prompt();
+  await parseResponse(100, p, fakeReasoningRes());
+  const msg = p.getLastMessage();
+  assert.strictEqual(msg.role, 'reasoning');
+  assert.strictEqual(msg.content[0].text, 'Thought.');
+});
+
+t.add('parseResponse: citations', async () => {
+  const p = new Prompt();
+  await parseResponse(100, p, fakeCitationRes());
+  const log = p.messages.find(m => m.role === 'log');
+  assert.ok(log);
+  assert.ok(log.content[0].text.includes('https://ex.com'));
+});
+
+t.add('parseResponse: function_call', async () => {
+  const p = new Prompt();
+  p.add('user', 'Weather');
+  await parseResponse(100, p, fakeToolRes());
+  const msg = p.getLastMessage();
+  assert.strictEqual(msg.role, 'assistant');
+  assert.strictEqual(msg.content[0].type, 'function_request');
+  assert.strictEqual(msg.content[0].function_request.name, 'get_current_weather');
+  assert.strictEqual(msg.content[0].function_request.parameters, '{"location":"Amsterdam"}');
+  assert.strictEqual(msg.content[0].function_request.call_id, 'fcid');
+});
+
+t.add('parseResponse: toolset exec', async () => {
+  const p = new Prompt();
+  p.add('user', 'Weather Amsterdam');
+  await parseResponse(100, p, fakeToolRes('get_current_weather', '{"location":"Amsterdam"}'), tools);
+  const toolMsg = p.getLastMessage();
+  assert.strictEqual(toolMsg.role, 'tool');
+  assert.strictEqual(toolMsg.content[0].type, 'function_response');
+  assert.strictEqual(toolMsg.content[0].function_response.name, 'get_current_weather');
+  assert.ok(toolMsg.content[0].function_response.response.includes('24 C'));
+});
+
+t.add('parseResponse: non-200 rejects', async () => {
+  const p = new Prompt();
+  const bad = { status: 400, response: { error: 'bad' } };
+  await assert.rejects(async () => parseResponse(100, p, bad), /400: /);
+});
+
+t.add('request: real simple', async () => {
+  const p = new Prompt();
+  p.add('system', 'You are a helpful assistant. Answer briefly.', true);
+  p.add('user', 'What is 2+2?');
+  const msg = await request(p);
+  assert.strictEqual(msg.role, 'assistant');
+  assert.ok(msg.content.some(c => c.type === 'text' && c.text.includes('4')), 'Expected 4');
+});
+
+const report = await t.run();
+process.exit(report.errors > 0 ? 1 : 0);

package/scenarios.bak.1774780058/xaicoll.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { Test, assert, SH } from '@j-o-r/sh'
+import collections  from '../lib/API/x.ai/collections.js';
+import path from 'node:path'
+
+
+import Prompt from '../lib/Prompt.js';
+import tools from './testToolset.js';
+
+function LOG(me) {
+	console.log(JSON.stringify(me, null, '  '));
+}
+
+const test = new Test();
+
+test.add('List collections, start in a clean state', async () => {
+	const list = await collections.list();
+	let i = 0;
+	const len = list.length;
+	for (; i < len; i++) {
+		const col = list[i];
+		if (col.collection_name === 'test_col' || col.collection_name === 'test_col2') {
+			const check = await collections.get(col.collection_id);
+			assert.equal(check.collection_id, col.collection_id);
+			// Delete all test collections
+			await collections.del(check.collection_id);
+		}
+	}
+});
+
+test.add('Add, update, delete a collection', async () => {
+	const coll_id = await collections.create('test_col');
+	let coll = await collections.get(coll_id);
+	assert.strictEqual(coll_id, coll.collection_id);
+	await collections.update(coll_id, 'test_col2');
+	coll = await collections.get(coll_id);
+	assert.strictEqual(coll.collection_name, 'test_col2');
+	await collections.del(coll_id);
+	// DELETED
+  await assert.rejects(
+		async () => await collections.get(coll_id),
+		(err) => {
+			return err.toString().includes('doesn\'t exist or your team');
+		}
+  )
+})
+
+
+
+await test.run();

package/scenarios.bak.1774780058/xaifiles.js

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+import { Test, assert, SH } from '@j-o-r/sh'
+import { files } from '../lib/API/x.ai/files.js';
+import path from 'node:path'
+
+import Prompt from '../lib/Prompt.js';
+import tools from './testToolset.js';
+
+function LOG(me) {
+	console.log(JSON.stringify(me, null, '  '));
+}
+
+const test = new Test();
+
+test.add('List files', async () => {
+	const fp = path.resolve('docs', 'toolset.md');
+	const list = (await files.list()).data;
+	let i = 0;
+	const len = list.length;
+	for(;i < len; i++) {
+		const f = list[i];
+		if (f.filename === 'test.md' || f.filename === fp) {
+			await files.rm(f.id);
+		}
+	}
+});
+
+test.add('create, add and remove files', async () => {
+	const fp = path.resolve('docs', 'toolset.md');
+	const res = await files.upload(fp);
+	const content = await files.get(res.id);
+	assert.equal(content.length, res.bytes);
+	const meta = await files.getMeta(res.id);
+	assert.equal(content.length, meta.bytes);
+  await files.rm(res.id);
+})
+
+test.add('create, add and remove files with custom content', async () => {
+	const fp = 'test.md';
+	// Add custom content to a file instead of reading the file itself
+	const res = await files.upload(fp, 'Hello World');
+	const content = await files.get(res.id);
+	assert.equal(content, 'Hello World');
+	const meta = await files.getMeta(res.id);
+	assert.equal(content.length, meta.bytes);
+  await files.rm(res.id);
+})
+await test.run();

package/types/API/openai.com/reponses/text.d.ts

@@ -33,7 +33,7 @@ export type OAOptions = {
     /**
      * - Model version to use.
      */
-    model?: "gpt-4.1" | "GPT-4o" | "o3" | "o3-mini" | "o4-mini" | "o1" | "o3-pro" | undefined;
+    model?: "gpt-5.4" | "gpt-5-mini" | "gpt-5-nano" | "gpt-5-pro" | undefined;
     /**
      * - Reusable prompt string.
      */
@@ -51,6 +51,9 @@ export type OAOptions = {
          */
         summary: "auto" | "concise" | "detailed";
     } | undefined;
+    /**
+     * - Convenience: Adds `{type: "web_search_preview", search_context_size: search}` tool.
+     */
     search?: "low" | "high" | "medium" | undefined;
     /**
      * - Service tier option, default is auto-selected.
@@ -86,9 +89,9 @@ export type OAOptions = {
      */
     tool_choice?: "auto" | undefined;
     /**
-     * =[] Array of tool call objects.
+     * - Array of tool objects: custom function tools (`OAToolCall`) or built-in OpenAI tools (e.g., `{type: "web_search_preview"}`).
      */
-    tools: OAToolCall[];
+    tools?: OpenAITool[] | undefined;
     /**
      * =null An integer between 0 and 20 specifying the number of most likely tokens to return at each token position, each with an associated log probability.
      */
@@ -126,6 +129,17 @@ export type OAToolCall = {
         required?: string[] | undefined;
     };
 };
+export type OABuiltinTool = {
+    /**
+     * - Type of built-in OpenAI tool (Responses API).
+     */
+    type: "code_interpreter" | "file_search" | "computer" | "web_search";
+    /**
+     * - Context size for `web_search_preview` only.
+     */
+    search_context_size?: "low" | "high" | "medium" | undefined;
+};
+export type OpenAITool = OAToolCall | OABuiltinTool;
 export type OAParameterProperty = {
     /**
      * - The data type of the parameter, e.g., "string".

package/types/API/x.ai/collections.d.ts

@@ -0,0 +1,167 @@
+declare namespace _default {
+    export { create };
+    export { list };
+    export { get };
+    export { status };
+    export { details };
+    export { update };
+    export { del };
+    export { addFileToCollection };
+    export { deleteFileFromCollection };
+    export { searchInCollections };
+    export { getStorage as storage };
+}
+export default _default;
+export type Collection = {
+    /**
+     * - Unique identifier for the collection.
+     */
+    collection_id: string;
+    /**
+     * - Name of the collection.
+     */
+    collection_name: string;
+    /**
+     * - ISO datetime string when the collection was created.
+     */
+    created_at: string;
+    updated_at: string;
+    /**
+     * - Configuration for the indexing model.
+     */
+    index_configuration: {
+        model_name: string;
+    };
+    /**
+     * - Configuration for chunking documents.
+     */
+    chunk_configuration: {
+        tokens_configuration: {
+            max_chunk_size_tokens: number;
+            chunk_overlap_tokens: number;
+            encoding_name: string;
+        };
+        strip_whitespace: boolean;
+        inject_name_into_chunks: boolean;
+    };
+    /**
+     * - Number of documents in the collection.
+     */
+    documents_count: number;
+    /**
+     * - Array of field definitions.
+     */
+    field_definitions: any[];
+};
+export type fileList = {
+    data: File[];
+    pagination_token: string | null;
+};
+export type File = {
+    /**
+     * - File size in bytes.
+     */
+    bytes: number;
+    /**
+     * - Unix timestamp of creation.
+     */
+    created_at: number;
+    /**
+     * - Unix timestamp of expiration, or null.
+     */
+    expires_at: number | null;
+    /**
+     * - Path to the file.
+     */
+    filename: string;
+    /**
+     * - Unique file identifier.
+     */
+    id: string;
+    /**
+     * - Type of object, e.g., 'file'.
+     */
+    object: string;
+    /**
+     * - Purpose of the file.
+     */
+    purpose: string;
+};
+export type SearchResult = {
+    document_id: string;
+    content: string;
+    metadata: Object;
+    score: number;
+};
+/**
+ * Create a collection
+ * @param {string} name
+ * @returns {Promise<string>} collection_id
+ */
+declare function create(name: string): Promise<string>;
+/**
+ * List collections
+ * @returns {Promise<Array<Collection>>}
+ */
+declare function list(): Promise<Array<Collection>>;
+/**
+ * Get collection details
+ * @param {string} id
+ * @returns {Promise<Collection>}
+ */
+declare function get(id: string): Promise<Collection>;
+/**
+ * The status of files in a collection
+ * @param {string} collectionId
+ * @returns {Promise<void>}
+ */
+declare function status(collectionId: string): Promise<void>;
+/**
+ * The status of files in a collection
+ * @param {string} collectionId
+ * @param {string} fileId
+ * @returns {Promise<void>}
+ */
+declare function details(collectionId: string, fileId: string): Promise<void>;
+/**
+ * Update collection collection name
+ * @param {string} id
+ * @param {string} name
+ * @returns {Promise<void>}
+ */
+declare function update(id: string, name: string): Promise<void>;
+/**
+ * Delete collection
+ * @param {string} id
+ * @returns {Promise<void>}
+ */
+declare function del(id: string): Promise<void>;
+/**
+ * Add file to collection
+ * @param {string} collectionId
+ * @param {string} fileId
+ * @returns {Promise<void>}
+ */
+declare function addFileToCollection(collectionId: string, fileId: string): Promise<void>;
+/**
+ * Delete file from collection
+ * @param {string} collectionId
+ * @param {string} fileId
+ * @returns {Promise<void>}
+ */
+declare function deleteFileFromCollection(collectionId: string, fileId: string): Promise<void>;
+/**
+ * Search in collections
+ * @param {string} query
+ * @param {string[]} collectionIds
+ * @param {Object} [options]
+ * @param {string} [options.retrieval_mode] - e.g., 'hybrid'
+ * @returns {Promise<SearchResult[]>}
+ */
+declare function searchInCollections(query: string, collectionIds: string[], options?: {
+    retrieval_mode?: string | undefined;
+}): Promise<SearchResult[]>;
+/**
+* @returns {Promise<Map<string, Collection>>}
+*/
+declare function getStorage(): Promise<Map<string, Collection>>;

package/types/API/x.ai/files.d.ts

@@ -0,0 +1,84 @@
+declare namespace _default {
+    export { list };
+    export { upload };
+    export { get };
+    export { getMeta };
+    export { rm };
+    export { getStorage as storage };
+}
+export default _default;
+export type fileList = {
+    data: File[];
+    pagination_token: string | null;
+};
+export type File = {
+    /**
+     * - File size in bytes.
+     */
+    bytes: number;
+    /**
+     * - Unix timestamp of creation.
+     */
+    created_at: number;
+    /**
+     * - Unix timestamp of expiration, or null.
+     */
+    expires_at: number | null;
+    /**
+     * - Path to the file.
+     */
+    filename: string;
+    /**
+     * - Unique file identifier.
+     */
+    id: string;
+    /**
+     * - Type of object, e.g., 'file'.
+     */
+    object: string;
+    /**
+     * - Purpose of the file.
+     */
+    purpose: string;
+};
+/**
+ * List Files
+ * @param {number} limit
+ * @param {'asc'|'desc'} order
+ * @param {'created_at'|'filename'| 'size'} sort_by
+ * @param {string} page (pagination_token)
+ * @retuns {Promise<fileList>}
+ */
+declare function list(limit?: number, order?: "asc" | "desc", sort_by?: "created_at" | "filename" | "size", page?: string): Promise<any>;
+/**
+ * Upload a file
+ * When content is filled this will be used as file content
+ * @param {string} filePath
+ * @param {string} [content] - optional content for a non existing file
+ * @returns {Promise<File>} file_id
+ */
+declare function upload(filePath: string, content?: string): Promise<File>;
+/**
+ * Get file content
+ * @param {string} fileId
+ * @returns {Promise<*>}
+ */
+declare function get(fileId: string): Promise<any>;
+/**
+ * Get file meta data
+ * @param {string} fileId
+ * @returns {Promise<File>}
+ */
+declare function getMeta(fileId: string): Promise<File>;
+/**
+ * Remove a file
+ * @param {string} fileId
+ * @returns {Promise<void>}
+ */
+declare function rm(fileId: string): Promise<void>;
+/**
+* Get all on-line files
+* @returns {Promise<Map<string, File>>}
+*
+*/
+declare function getStorage(page?: string): Promise<Map<string, File>>;